Radicade/Server/Storefront/StorefrontsV2.cs

using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using RadicadeServer.DB;
using RadicadeServer.Extensions;
using RadicadeServer.RecNet.Avatar;
using RadicadeServer.RecNet.Enums;
using RadicadeServer.RecNet.Enums.Store;
using RadicadeServer.RecNet.Storefront;

namespace RadicadeServer.API.Storefront.V2;

[Route("api/storefronts/v2")]
[Route("econ/api/storefronts/v2")]
public class StorefrontsV2(RecDBContext db) : Controller
{
    [HttpGet("balance"), Authorize]
    public async Task<IActionResult> GetBalances()
    {
        var userId = User.GetUserId();
        if (userId == null) return Unauthorized();

        var data = await db.Currency.FirstOrDefaultAsync(x => x.AccountId == userId.Value);
        if (data == null)
            return Ok(new List<RadicadeServer.RecNet.Responses.BalanceResponse>());

        return Ok(new List<RadicadeServer.RecNet.Responses.BalanceResponse>
        {
            new() { CurrencyType = CurrencyType.RecCenterTokens, Balance = data.RecTokens },
            new() { CurrencyType = CurrencyType.LaserTagTickets, Balance = data.LaserTagTickets },
            new() { CurrencyType = CurrencyType.LostSkullsGold, Balance = data.Gold },
            new() { CurrencyType = CurrencyType.DraculaSilver, Balance = data.DraculaSilver }
        });
    }

    [HttpPost("balance"), Authorize]
    public async Task<IActionResult> ModifyBalance([FromBody] GrantBalanceRewardDTO? request)
    {
        var userId = User.GetUserId();
        if (userId == null || request == null || request.BalanceAdds is not { Count: > 0 })
            return BadRequest();

        var currency = await db.Currency.FirstOrDefaultAsync(x => x.AccountId == userId.Value);
        if (currency == null) return NotFound();






        const int baseAward = 10;
        long awarded = 0;
        var updates = new List<BalanceUpdateEntry<RewardBalanceModificationDTO>>();

        foreach (var grant in request.BalanceAdds)
        {
            if (grant == null) continue;

            long total = (long)(baseAward * (double)grant.Multiplier);
            if (total <= 0) total = baseAward;

            StorefrontShared.AddCurrency(currency, request.CurrencyType, total);
            awarded += total;

            updates.Add(new()
            {
                UpdateResponse = UpdateResponseTypes.OK,
                Data = new RewardBalanceModificationDTO
                {
                    BalanceAddType = grant.BalanceAddType,
                    BaseAward = baseAward,
                    BonusAward = 0,
                    Total = (int)total,
                    CurrentCount = 1,
                    RateLimit = 0
                }
            });
        }

        await db.SaveChangesAsync();

        long newBalance = StorefrontShared.GetBalance(currency, request.CurrencyType);

        return Ok(new BalanceUpdateResponse<RewardBalanceModificationDTO>
        {
            CurrencyType = request.CurrencyType,
            Balance = newBalance,
            BalanceUpdates = updates
        });
    }



    [HttpPost("buyItem"), Authorize]
    public async Task<IActionResult> BuyItem([FromBody] RequestPurchaseItemDTO? request)
    {
        var userId = User.GetUserId();
        if (userId == null) return Unauthorized();

        if (request == null)
        {
            return BadRequest(new { error = "invalid_request" });
        }

        var outcome = await StorefrontShared.ExecutePurchaseAsync(
            db,
            userId.Value,
            request.StorefrontType,
            request.PurchasableItemId,
            request.CurrencyType,
            request.RequestedPrice,
            request.Gift);

        if (outcome.Response != null)
            return Ok(outcome.Response);
        return outcome.Error switch
        {
            "cannot_gift_self" or "invalid_recipient" => BadRequest(new { error = outcome.Error, message = outcome.ErrorDetail }),
            _ => StatusCode(StatusCodes.Status500InternalServerError, new { error = outcome.Error, message = outcome.ErrorDetail })
        };
    }
}