Lots of additions and changes

TOOHUCardAPI/Controllers/MethodBasedController.cs

@@ -11,10 +11,10 @@ namespace TOOHUCardAPI.Controllers
 {
     public class MethodBasedController : ControllerBase
     {
-        public delegate Task<object> EndpointHandler(string requestBody);
+        public delegate Task<IActionResult> EndpointHandler(string requestBody);
         private static Dictionary<Type, MethodMap> MethodMapByType = new Dictionary<Type, MethodMap>();
         
-        protected Task<object> InvokeEndpointHandlerForMethod<T>(object _this, string method, string body)
+        protected Task<IActionResult> InvokeEndpointHandlerForMethod<T>(object _this, string method, string body)
         {
             MethodMap registeredEndpointHandlers = GetMethodMapForType<T>();
             if (registeredEndpointHandlers.ContainsKey(method))

TOOHUCardAPI/Controllers/PlayerBaseDataController.cs

@@ -2,14 +2,41 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
+using AutoMapper;
 using Microsoft.AspNetCore.Http;
 using Microsoft.AspNetCore.Mvc;
+using Microsoft.Extensions.Logging;
+using TOOHUCardAPI.Data.Models;
+using TOOHUCardAPI.Data.Repositories;
+using TOOHUCardAPI.DTO;
 
 namespace TOOHUCardAPI.Controllers
 {
     [Route("api/[controller]")]
     [ApiController]
-    public class PlayerBaseDataController : ControllerBase
+    public class PlayerBaseDataController : MethodBasedController
     {
+        private readonly ILogger<PlayerBaseDataController> _logger;
+        private readonly UserRepository _userRepository;
+        private readonly IMapper _mapper;
+
+        public PlayerBaseDataController(ILogger<PlayerBaseDataController> logger, UserRepository userRepository, IMapper mapper)
+        {
+            _logger = logger;
+            _userRepository = userRepository;
+            _mapper = mapper;
+        }
+
+        [HttpGet]
+        public async Task<IActionResult> Get(string id)
+        {
+            User user = _userRepository.GetUser(id);
+            if (user == null)
+            {
+                return BadRequest("Invalid user id specified");
+            }
+
+            return Ok(_mapper.Map<PlayerBaseDataResponse>(user));
+        }
     }
 }

TOOHUCardAPI/Controllers/PlayerDataController.cs

@@ -16,7 +16,9 @@ using Newtonsoft.Json.Linq;
 using TOOHUCardAPI.Data;
 using TOOHUCardAPI.Data.Models;
 using TOOHUCardAPI.Data.Repositories;
+using TOOHUCardAPI.Data.Services;
 using TOOHUCardAPI.DTO;
+using TOOHUCardAPI.DTO.PlayerData;
 
 namespace TOOHUCardAPI.Controllers
 {
@@ -27,12 +29,14 @@ namespace TOOHUCardAPI.Controllers
         private readonly ILogger<PlayerDataController> _logger;
         private readonly UserRepository _userRepository;
         private readonly IMapper _mapper;
+        private readonly StoreService _storeService;
 
-        public PlayerDataController(ILogger<PlayerDataController> logger, UserRepository userRepository, IMapper mapper)
+        public PlayerDataController(ILogger<PlayerDataController> logger, UserRepository userRepository, IMapper mapper, StoreService storeService)
         {
             _logger = logger;
             _userRepository = userRepository;
             _mapper = mapper;
+            _storeService = storeService;
         }
 
         /**
@@ -41,27 +45,71 @@ namespace TOOHUCardAPI.Controllers
          * So let's use a single entry point and redirect based on that
          */
         [HttpPost]
-        public async Task<object> EntryPoint([FromBody] object bodyObj)
+        public async Task<IActionResult> EntryPoint([FromBody] object bodyObj)
         {
             string body = JsonConvert.SerializeObject(bodyObj);
             JObject request = JObject.Parse(body);
             string method = request["method"].ToString();
-            return await InvokeEndpointHandlerForMethod<PlayerDataController>(this, method, body);
+            try
+            {
+                return await InvokeEndpointHandlerForMethod<PlayerDataController>(this, method, body);
+            }
+            catch (TooHooException e)
+            {
+                return Ok(e.response);
+            }
         }
 
-        [EndpointHandler("save_card_group")]
-        private async Task<object> SaveCardGroup(string body)
+        [EndpointHandler("day_first_win")]
+        private async Task<IActionResult> GiveFirstWin(string body)
         {
-            PlayerDataSaveCardGroupRequestObject request =
-                JsonConvert.DeserializeObject<PlayerDataSaveCardGroupRequestObject>(body);
+            PlayerDataFirstWinRequest request = JsonConvert.DeserializeObject<PlayerDataFirstWinRequest>(body);
+            var bonusPoints = await _storeService.GiveFirstWinBonus(request.SteamId);
+
+            return Ok(new PlayerDataFirstWinResponse
+            {
+                BonusPoints = bonusPoints
+            });
+        }
+
+        [EndpointHandler("save_key_count")]
+        private async Task<IActionResult> SaveKeyCount(string body)
+        {
+            PlayerDataSaveKeyCountRequest request = JsonConvert.DeserializeObject<PlayerDataSaveKeyCountRequest>(body);
             User user = _userRepository.GetUser(request.SteamId);
             if (user == null)
             {
-                return new PlayerDataSaveCardGroupResponseObject()
-                {
-                    Code = "0001",
-                    Message = "Invalid player"
-                };
+                throw new InvalidUserException();
+            }
+
+            user.KeyTotal = request.KeyTotal;
+            user.KeyUseCount = request.KeyUseCount;
+            _userRepository.UpdateUser(user);
+            return Ok(new OkResponse());
+        }
+
+        [EndpointHandler("buy_key")]
+        private async Task<IActionResult> BuyMagicKey(string body)
+        {
+            PlayerDataBuyMagicKeyRequest request = JsonConvert.DeserializeObject<PlayerDataBuyMagicKeyRequest>(body);
+
+            var totalCost = await _storeService.PurchaseMagicKey(request.Count, request.SteamId);
+            
+            return Ok(new PlayerDataBuyMagicKeyResponse
+            {
+                TotalCost = totalCost
+            });
+        }
+
+        [EndpointHandler("save_card_group")]
+        private async Task<IActionResult> SaveCardGroup(string body)
+        {
+            PlayerDataSaveCardGroupRequest request =
+                JsonConvert.DeserializeObject<PlayerDataSaveCardGroupRequest>(body);
+            User user = _userRepository.GetUser(request.SteamId);
+            if (user == null)
+            {
+                throw new InvalidUserException();
             }
 
             EncodedCardGroup group = user.EncodedCardGroups.FirstOrDefault(group => group.GroupKey == request.GroupKey) ?? new EncodedCardGroup()
@@ -71,18 +119,18 @@ namespace TOOHUCardAPI.Controllers
             group.EncodedString = request.GroupData;
             user.EncodedCardGroups = user.EncodedCardGroups.Where(group2 => group.Id != group2.Id).Append(group).ToList();
             _userRepository.UpdateUser(user);
-            return new PlayerDataSaveCardGroupResponseObject();
+            return Ok(new PlayerDataSaveCardGroupResponseObject());
         }
 
         [EndpointHandler("get")]
-        private async Task<object> Get(string body)
+        private async Task<IActionResult> Get(string body)
         {
             PlayerDataGetRequestObject requestObject = JsonConvert.DeserializeObject<PlayerDataGetRequestObject>(body);
             IEnumerable<User> users = requestObject.Ids.Values.Select(val => _userRepository.GetOrCreateUser(val));
             IEnumerable<string> queriedUserSteamIds = requestObject.Ids.Select(i => i.Value);
             IEnumerable<PlayerDataGetResponseObjectPlayer> responsePlayers = users
                 .Where(user => queriedUserSteamIds.Contains(user.SteamId))
-                .Select(user => _mapper.Map<PlayerDataGetResponseObjectPlayer>(user));
+                .Select(user => user.ToGetResponse(_mapper));
             Dictionary<string, PlayerDataGetResponseObjectPlayer> playersStatic = requestObject.Ids
                 .Select(pair =>
                     KeyValuePair.Create(pair.Key, responsePlayers.FirstOrDefault(resp => resp.SteamId == pair.Value)))
@@ -108,7 +156,7 @@ namespace TOOHUCardAPI.Controllers
                 Players = dynamicResponses
             };
 
-            return response;
+            return Ok(response);
         }
         
     }