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();
+            try
+            {
                 return await InvokeEndpointHandlerForMethod<PlayerDataController>(this, method, body);
             }
-
-        [EndpointHandler("save_card_group")]
-        private async Task<object> SaveCardGroup(string body)
+            catch (TooHooException e)
             {
-            PlayerDataSaveCardGroupRequestObject request =
-                JsonConvert.DeserializeObject<PlayerDataSaveCardGroupRequestObject>(body);
+                return Ok(e.response);
+            }
+        }
+
+        [EndpointHandler("day_first_win")]
+        private async Task<IActionResult> GiveFirstWin(string 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()
+                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)
         {
-                    Code = "0001",
-                    Message = "Invalid player"
-                };
+            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);
         }
         
     }

TOOHUCardAPI/DTO/AbstractPlayerTargetedRequest.cs

@@ -0,0 +1,7 @@
+namespace TOOHUCardAPI.DTO
+{
+    public abstract class AbstractPlayerTargetedRequest : AbstractRequest
+    {
+        public string SteamId { get; set; }
+    }
+}

TOOHUCardAPI/DTO/AbstractResponse.cs

@@ -11,4 +11,17 @@ namespace TOOHUCardAPI.DTO
         [JsonProperty("msg")]
         public string Message { get; set; } = string.Empty;
     }
+
+    public class InvalidUserResponse : AbstractResponse
+    {
+        public InvalidUserResponse()
+        {
+            Code = "0001";
+            Message = "Invalid user";
+        }
+    }
+
+    public class OkResponse : AbstractResponse
+    {
+    }
 }

TOOHUCardAPI/DTO/PlayerBaseDataResponse.cs

@@ -0,0 +1,17 @@
+using Newtonsoft.Json;
+
+namespace TOOHUCardAPI.DTO
+{
+    public class PlayerBaseDataResponse: AbstractResponse
+    {
+        [JsonProperty("steamid")]
+        public string SteamId { get; set; }
+        [JsonProperty("pet_level")] public int PetLevel { get; set; } = 1;
+        [JsonProperty("end_time")] public string EndTime { get; set; } = string.Empty;
+        [JsonProperty("key_total")] public int KeyTotal { get; set; } = 100;
+        [JsonProperty("key_save_date")] public string KeySaveDate { get; set; } = string.Empty;
+        [JsonProperty("vip")] public int Vip { get; set; } = 1;
+        [JsonProperty("point")] public int Point { get; set; } = 10000;
+        [JsonProperty("level_list")] public string LevelList { get; set; } = string.Empty;
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataBuyMagicKeyRequest.cs

@@ -0,0 +1,8 @@
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataBuyMagicKeyRequest : AbstractPlayerTargetedRequest
+    {
+        public string UserId { get; set; }
+        public int Count { get; set; }
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataBuyMagicKeyResponse.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataBuyMagicKeyResponse : AbstractResponse
+    {
+        [JsonProperty("cost_point")]
+        public int TotalCost { get; set; }
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataFirstWinRequest.cs

@@ -0,0 +1,7 @@
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataFirstWinRequest : AbstractPlayerTargetedRequest
+    {
+        
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataFirstWinResponse.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataFirstWinResponse : AbstractResponse
+    {
+        [JsonProperty("bonus_point")]
+        public int BonusPoints { get; set; }
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataGetRequest.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataGetRequestObject : AbstractRequest
+    {
+        public Dictionary<string, string> Ids;
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataGetResponseObject.cs

@@ -1,15 +1,16 @@
+using System;
 using System.Collections.Generic;
-using System.Dynamic;
 using System.Linq;
 using System.Reflection;
 using AutoMapper;
 using Newtonsoft.Json;
 using TOOHUCardAPI.Data.Models;
 
-namespace TOOHUCardAPI.DTO
+namespace TOOHUCardAPI.DTO.PlayerData
 {
-    public class PlayerDataGetResponseObject
+    public class PlayerDataGetResponseObject: AbstractResponse
     {
+        // Instead of using a defined object, use a dictionary so we can add the necessary cardgroup items. I dont want to make 20 of them in the class
         [JsonProperty("bo")]
         public Dictionary<string, Dictionary<string, object>> Players { get; set; }
         
@@ -31,6 +32,8 @@ namespace TOOHUCardAPI.DTO
         [JsonProperty("vip")] public int Vip { get; set; } = 1;
         [JsonProperty("point")] public int Point { get; set; } = 10000;
         [JsonProperty("level_list")] public string LevelList { get; set; } = string.Empty;
+        [JsonProperty("is_first_win")]public int IsFirstWin { get; set; }
+        [JsonProperty("key_use_count")] public int KeyUseCount { get; set; }
 
         public Dictionary<string, object> ToDynamicProperties()
         {
@@ -39,8 +42,14 @@ namespace TOOHUCardAPI.DTO
         }
     }
     
-    public class PlayerDataSaveCardGroupResponseObject : AbstractResponse
+    public static class PlayerDataGetResponseExtensions
     {
+        public static PlayerDataGetResponseObjectPlayer ToGetResponse(this User user, IMapper mapper)
+        {
+            PlayerDataGetResponseObjectPlayer responseObject = mapper.Map<PlayerDataGetResponseObjectPlayer>(user);
+            responseObject.IsFirstWin = user.LastFirstWin.AddDays(1) < DateTime.Now ? 1 : 0;
 
+            return responseObject;
+        }
     }
 }

TOOHUCardAPI/DTO/PlayerData/PlayerDataSaveCardGroupRequest.cs

@@ -0,0 +1,13 @@
+using Newtonsoft.Json;
+
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataSaveCardGroupRequest: AbstractPlayerTargetedRequest
+    {
+        public string UserId { get; set; }
+        [JsonProperty("group_key")]
+        public string GroupKey { get; set; }
+        [JsonProperty("group_data")]
+        public string GroupData { get; set; }
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataSaveCardGroupResponse.cs

@@ -0,0 +1,7 @@
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataSaveCardGroupResponseObject : AbstractResponse
+    {
+        
+    }
+}

TOOHUCardAPI/DTO/PlayerData/PlayerDataSaveKeyCountRequest.cs

@@ -0,0 +1,11 @@
+using Newtonsoft.Json;
+
+namespace TOOHUCardAPI.DTO.PlayerData
+{
+    public class PlayerDataSaveKeyCountRequest: AbstractPlayerTargetedRequest
+    {
+        public string UserId { get; set; }
+        [JsonProperty("key_total")]public int KeyTotal { get; set; }
+        [JsonProperty("key_use_count")]public int KeyUseCount { get; set; }
+    }
+}

TOOHUCardAPI/DTO/PlayerDataRequestObjects.cs

@@ -1,20 +0,0 @@
-using System.Collections.Generic;
-using Newtonsoft.Json;
-
-namespace TOOHUCardAPI.DTO
-{
-    public class PlayerDataGetRequestObject : AbstractRequest
-    {
-        public Dictionary<string, string> Ids;
-    }
-
-    public class PlayerDataSaveCardGroupRequestObject: AbstractRequest
-    {
-        public string SteamId { get; set; }
-        public string UserId { get; set; }
-        [JsonProperty("group_key")]
-        public string GroupKey { get; set; }
-        [JsonProperty("group_data")]
-        public string GroupData { get; set; }
-    }
-}

TOOHUCardAPI/Data/AppDbContext.cs

@@ -6,11 +6,18 @@ namespace TOOHUCardAPI.Data
     public class AppDbContext : DbContext
     {
         public DbSet<User> Users { get; set; }
+        public DbSet<Card> Cards { get; set; }
 
         public AppDbContext(DbContextOptions options) : base(options)
         {
         }
 
+        protected override void OnModelCreating(ModelBuilder modelBuilder)
+        {
+            base.OnModelCreating(modelBuilder);
+            
+        }
+
         protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
         {
             base.OnConfiguring(optionsBuilder);

TOOHUCardAPI/Data/AppSettings.cs

@@ -0,0 +1,33 @@
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+
+namespace TOOHUCardAPI.Data
+{
+    public static class AppSettings
+    {
+        public static int PointsPerLevel { get; set; }
+        public static int PointsPerLevelNormal { get; set; }
+        public static int FirstWinBonusPoints { get; set; }
+        public static int PointsPerKey { get; set; }
+        public static int MaxKeyPurchaseAmount { get; set; }
+        public static void Init(IConfiguration configuration)
+        {
+            var fields = typeof(AppSettings).GetProperties();
+            foreach (var propertyInfo in fields)
+            {
+                if (propertyInfo.PropertyType == typeof(string))
+                {
+                    propertyInfo.SetValue(null, configuration.GetValue<string>(propertyInfo.Name));
+                }
+                else if (propertyInfo.PropertyType == typeof(int))
+                {
+                    propertyInfo.SetValue(null, configuration.GetValue<int>(propertyInfo.Name));
+                }
+                else if (propertyInfo.PropertyType == typeof(double))
+                {
+                    propertyInfo.SetValue(null, configuration.GetValue<double>(propertyInfo.Name));
+                }
+            }
+        }
+    }
+}

TOOHUCardAPI/Data/AutomapProfile.cs

@@ -1,6 +1,7 @@
 using AutoMapper;
 using TOOHUCardAPI.Data.Models;
 using TOOHUCardAPI.DTO;
+using TOOHUCardAPI.DTO.PlayerData;
 
 namespace TOOHUCardAPI.Data
 {
@@ -9,6 +10,8 @@ namespace TOOHUCardAPI.Data
         public AutomapProfile()
         {
             CreateMap<User, PlayerDataGetResponseObjectPlayer>();
+            CreateMap<User, PlayerBaseDataResponse>();
+            
         }
     }
 }

TOOHUCardAPI/Data/Enums/Rarity.cs

@@ -0,0 +1,10 @@
+namespace TOOHUCardAPI.Data.Enums
+{
+    public enum Rarity
+    {
+        NORMAL = 1,
+        RARE = 2,
+        SUPER_RARE = 3,
+        SUPER_SECRET_RARE = 4
+    }
+}

TOOHUCardAPI/Data/Exceptions.cs

@@ -0,0 +1,25 @@
+using System;
+using TOOHUCardAPI.Data.Services;
+using TOOHUCardAPI.DTO;
+
+namespace TOOHUCardAPI.Data
+{
+    public abstract class TooHooException : Exception
+    {
+        public abstract AbstractResponse response { get; }
+    }
+    public class InvalidUserException : TooHooException
+    {
+        public override AbstractResponse response => new InvalidUserResponse();
+    }
+
+    public class InsufficientPointsException : TooHooException
+    {
+        public override AbstractResponse response => new InsufficientPointsResponse();
+    }
+
+    public class NotFirstWinException : TooHooException
+    {
+        public override AbstractResponse response => new NotFirstWinResponse();
+    }
+}

TOOHUCardAPI/Data/Models/Card.cs

@@ -0,0 +1,15 @@
+using System.ComponentModel.DataAnnotations;
+using TOOHUCardAPI.Data.Enums;
+
+namespace TOOHUCardAPI.Data.Models
+{
+    public class Card
+    {
+        [Key]
+        public string ItemCode { get; set; }
+        public string CardName { get; set; }
+        public Rarity Rarity { get; set; }
+        public bool HasVoice { get; set; }
+        public bool HasPortrait { get; set; }
+    }
+}

TOOHUCardAPI/Data/Models/User.cs

@@ -13,10 +13,12 @@ namespace TOOHUCardAPI.Data.Models
         public int PetLevel { get; set; }
         public DateTime EndTime { get; set; }
         public int KeyTotal { get; set; }
+        public int KeyUseCount { get; set; }
         public DateTime KeySaveDate { get; set; }
         public bool Vip { get; set; }
         public bool Ban { get; set; }
         public int Point { get; set; }
+        public DateTime LastFirstWin { get; set; }
         public string LevelList { get; set; }
         public List<EncodedCardGroup> EncodedCardGroups { get; set; }
     }

TOOHUCardAPI/Data/Services/StoreService.cs

@@ -0,0 +1,87 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.Logging;
+using TOOHUCardAPI.Data.Models;
+using TOOHUCardAPI.Data.Repositories;
+using TOOHUCardAPI.DTO;
+
+namespace TOOHUCardAPI.Data.Services
+{
+    public class StoreService
+    {
+        private readonly ILogger<StoreService> _logger;
+        private readonly UserRepository _userRepository;
+
+        public StoreService(ILogger<StoreService> logger, UserRepository userRepository)
+        {
+            _logger = logger;
+            _userRepository = userRepository;
+        }
+
+        private void AddPoints(int points, User user)
+        {
+            user.Point = Math.Max(0, user.Point + points);
+            _userRepository.UpdateUser(user);
+            _logger.LogInformation($"User with steamid {user.SteamId} was given {points} points. New total: {user.Point}");
+        }
+
+        public async Task<int> PurchaseMagicKey(int amt, string steamId)
+        {
+            int totalCost = AppSettings.PointsPerKey * amt;
+            amt = Math.Clamp(amt, 0, AppSettings.MaxKeyPurchaseAmount);
+            User user = _userRepository.GetUser(steamId);
+            if (user == null)
+            {
+                throw new InvalidUserException();
+            }
+            if (user.Point < totalCost)
+            {
+                throw new InsufficientPointsException();
+            }
+
+            AddPoints(-totalCost, user);
+            user.KeyTotal += amt;
+            _userRepository.UpdateUser(user);
+            _logger.LogInformation($"User with steamid {user.SteamId} purchased {amt} keys for {totalCost} points. New point value is {user.Point}");
+            return totalCost;
+        }
+
+        public async Task<int> GiveFirstWinBonus(string steamId)
+        {
+            User user = _userRepository.GetUser(steamId);
+            if (user == null)
+            {
+                throw new InvalidUserException();
+            }
+
+            if (user.LastFirstWin.AddDays(1) > DateTime.Now)
+            {
+                throw new NotFirstWinException();
+            }
+            AddPoints(AppSettings.FirstWinBonusPoints, user);
+            user.LastFirstWin = DateTime.Now;
+            _userRepository.UpdateUser(user);
+            _logger.LogInformation($"User with steamid {user.SteamId} received first win of the day bonus, earning {AppSettings.FirstWinBonusPoints} points. New value: {user.Point}");
+            return AppSettings.FirstWinBonusPoints;
+        }
+    }
+
+    public class InsufficientPointsResponse : AbstractResponse
+    {
+        public InsufficientPointsResponse()
+        {
+            Code = "0002";
+            Message = "Insufficient points";
+        }
+    }
+
+    public class NotFirstWinResponse : AbstractResponse
+    {
+        public NotFirstWinResponse()
+        {
+            Code = "0003";
+            Message = "Not first win of the day";
+        }
+    }
+
+}

TOOHUCardAPI/Migrations/20211030045834_more columns.Designer.cs

@@ -0,0 +1,103 @@
+// <auto-generated />
+using System;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Microsoft.EntityFrameworkCore.Storage.ValueConversion;
+using TOOHUCardAPI.Data;
+
+namespace TOOHUCardAPI.Migrations
+{
+    [DbContext(typeof(AppDbContext))]
+    [Migration("20211030045834_more columns")]
+    partial class morecolumns
+    {
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+#pragma warning disable 612, 618
+            modelBuilder
+                .HasAnnotation("ProductVersion", "5.0.11");
+
+            modelBuilder.Entity("TOOHUCardAPI.Data.Models.EncodedCardGroup", b =>
+                {
+                    b.Property<int>("Id")
+                        .ValueGeneratedOnAdd()
+                        .HasColumnType("INTEGER");
+
+                    b.Property<string>("EncodedString")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("GroupKey")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("UserSteamId")
+                        .HasColumnType("TEXT");
+
+                    b.HasKey("Id");
+
+                    b.HasIndex("UserSteamId");
+
+                    b.ToTable("EncodedCardGroup");
+                });
+
+            modelBuilder.Entity("TOOHUCardAPI.Data.Models.User", b =>
+                {
+                    b.Property<string>("SteamId")
+                        .HasColumnType("TEXT");
+
+                    b.Property<bool>("Ban")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("EndTime")
+                        .HasColumnType("TEXT");
+
+                    b.Property<DateTime>("KeySaveDate")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("KeyTotal")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("KeyUseCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastFirstWin")
+                        .HasColumnType("TEXT");
+
+                    b.Property<string>("LevelList")
+                        .HasColumnType("TEXT");
+
+                    b.Property<int>("MaxTeamWave")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("MaxWave")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("PetLevel")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<int>("Point")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<bool>("Vip")
+                        .HasColumnType("INTEGER");
+
+                    b.HasKey("SteamId");
+
+                    b.ToTable("Users");
+                });
+
+            modelBuilder.Entity("TOOHUCardAPI.Data.Models.EncodedCardGroup", b =>
+                {
+                    b.HasOne("TOOHUCardAPI.Data.Models.User", null)
+                        .WithMany("EncodedCardGroups")
+                        .HasForeignKey("UserSteamId");
+                });
+
+            modelBuilder.Entity("TOOHUCardAPI.Data.Models.User", b =>
+                {
+                    b.Navigation("EncodedCardGroups");
+                });
+#pragma warning restore 612, 618
+        }
+    }
+}

TOOHUCardAPI/Migrations/20211030045834_more columns.cs

@@ -0,0 +1,36 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+namespace TOOHUCardAPI.Migrations
+{
+    public partial class morecolumns : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "KeyUseCount",
+                table: "Users",
+                type: "INTEGER",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "LastFirstWin",
+                table: "Users",
+                type: "TEXT",
+                nullable: false,
+                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "KeyUseCount",
+                table: "Users");
+
+            migrationBuilder.DropColumn(
+                name: "LastFirstWin",
+                table: "Users");
+        }
+    }
+}

TOOHUCardAPI/Migrations/AppDbContextModelSnapshot.cs

@@ -55,6 +55,12 @@ namespace TOOHUCardAPI.Migrations
                     b.Property<int>("KeyTotal")
                         .HasColumnType("INTEGER");
 
+                    b.Property<int>("KeyUseCount")
+                        .HasColumnType("INTEGER");
+
+                    b.Property<DateTime>("LastFirstWin")
+                        .HasColumnType("TEXT");
+
                     b.Property<string>("LevelList")
                         .HasColumnType("TEXT");
 

TOOHUCardAPI/Startup.cs

@@ -14,6 +14,7 @@ using Microsoft.Extensions.Logging;
 using Microsoft.OpenApi.Models;
 using TOOHUCardAPI.Data;
 using TOOHUCardAPI.Data.Repositories;
+using TOOHUCardAPI.Data.Services;
 
 namespace TOOHUCardAPI
 {
@@ -22,6 +23,7 @@ namespace TOOHUCardAPI
         public Startup(IConfiguration configuration)
         {
             Configuration = configuration;
+            AppSettings.Init(configuration);
         }
 
         public IConfiguration Configuration { get; }
@@ -35,6 +37,7 @@ namespace TOOHUCardAPI
                 opt.UseSqlite(Configuration.GetConnectionString("Sqlite"));
             });
             services.AddScoped<UserRepository>();
+            services.AddScoped<StoreService>();
             services.AddAutoMapper(typeof(AutomapProfile));
             services.AddSwaggerGen(c =>
             {

TOOHUCardAPI/appsettings.json

@@ -9,5 +9,10 @@
       "Microsoft.Hosting.Lifetime": "Information"
     }
   },
-  "AllowedHosts": "*"
+  "AllowedHosts": "*",
+  "PointsPerLevel": "10",
+  "PointsPerLevelNormal": "5",
+  "PointsPerKey": "2",
+  "FirstWinBonusPoints": "2",
+  "MaxKeyPurchaseAmount": "200"
 }