Product endpoint removed

Author: sollygit

MockMe.API/Controllers/MockController.cs

@@ -21,28 +21,11 @@ public class MockController : ControllerBase
         public MockController(IMockService mockService) =>
             (_mockService) = (mockService);
 
-        [HttpGet("Product")]
-        public async Task<IActionResult> Products([FromQuery(Name = "_limit")] int limit)
-        {
-            var items = await _mockService.GetProductsAsync(limit);
-            return new OkObjectResult(items);
-        }
-
-        [Authorize]
-        [HttpPost("[action]")]
-        public async Task<IActionResult> Product([FromBody] ProductRequest request)
-        {
-            if (request == null) return BadRequest(ModelState);
-
-            var data = await _mockService.ProductAdd(request);
-            return new OkObjectResult(data);
-        }
-
         [Authorize]
         [HttpGet("Country")]
-        public async Task<IActionResult> Countries()
+        public IActionResult Countries()
         {
-            var items = await _mockService.GetCountriesAsync();
+            var items = _mockService.GetCountries();
             return new OkObjectResult(items);
         }
 
@@ -80,15 +63,5 @@ public async Task<IActionResult> Reports()
             var items = Deserializer.FromJsonDictionary<Report>(json).OrderBy(o => o.Key);
             return new OkObjectResult(items);
         }
-
-        [Authorize]
-        [HttpGet(nameof(Technologies))]
-        public async Task<IActionResult> Technologies()
-        {
-            var path = @$"{Directory.GetCurrentDirectory()}\Shared\technologies.json";
-            var json = await System.IO.File.ReadAllTextAsync(path);
-            var items = Deserializer.FromJsonList<Technology>(json).OrderBy(o => o.TechnologyId);
-            return new OkObjectResult(items);
-        }
     }
 }

MockMe.API/Services/AssetService.cs

@@ -3,7 +3,6 @@
 using MockMe.API.ViewModels;
 using MockMe.Common;
 using MockMe.Model;
-using MockMe.Repository;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -19,12 +18,10 @@ public interface IAssetService
     public class AssetService : IAssetService
     {
         private readonly IMemoryCache cache;
-        private readonly ITradeRepository tradeRepository;
 
-        public AssetService(IMemoryCache cache, ITradeRepository tradeRepository)
+        public AssetService(IMemoryCache cache)
         {
             this.cache = cache;
-            this.tradeRepository = tradeRepository;
         }
 
         public async Task<IEnumerable<AssetViewModel>> GetAllAsync()
@@ -34,7 +31,7 @@ public async Task<IEnumerable<AssetViewModel>> GetAllAsync()
                 // Cache Assets
                 e.SetOptions(new MemoryCacheEntryOptions{ AbsoluteExpirationRelativeToNow = TimeSpan.FromDays(1) });
 
-                var currencyPairs = tradeRepository.CurrencyPairList();
+                var currencyPairs = ((IEnumerable<CurrencyPair>)Enum.GetValues(typeof(CurrencyPair))).ToList();
                 var result = currencyPairs.Select(pair => 
                     Mapper.Map<AssetViewModel>(new Asset((int)pair, pair.Description())));
                 return await Task.FromResult(result);

MockMe.API/Services/MockService.cs

@@ -1,19 +1,16 @@
-using Microsoft.Extensions.Caching.Memory;
+using Bogus;
+using Microsoft.Extensions.Caching.Memory;
 using Microsoft.Extensions.Logging;
-using MockMe.Common;
 using MockMe.Model;
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using System.Threading.Tasks;
 
 namespace MockMe.API.Services
 {
     public interface IMockService
     {
-        Task<Product> ProductAdd(ProductRequest request);
-        Task<IEnumerable<Country>> GetCountriesAsync();
-        Task<IEnumerable<Product>> GetProductsAsync(int count);
+        IEnumerable<Country> GetCountries();
     }
 
     public class MockService : IMockService
@@ -24,37 +21,18 @@ public class MockService : IMockService
         public MockService(ILogger<MockService> logger, IMemoryCache cache) =>
             (_logger, _cache) = (logger, cache);
 
-        public async Task<Product> ProductAdd(ProductRequest request)
-        {
-            var data = new Product();
-
-            try
-            {
-                _logger.LogInformation("ProductRequest: {request}", request.ToJson(true));
-
-                data = MockUtil.GetData(request);
-            }
-            catch (Exception ex)
-            {
-                _logger.LogError("ProductAdd Error {ex}", ex);
-            }
-
-            return await Task.FromResult(data);
-        }
-
-        public async Task<IEnumerable<Country>> GetCountriesAsync()
+        public IEnumerable<Country> GetCountries()
         {
             // Cache Countries for 24hrs due to high page load
-            return await _cache.GetOrCreateAsync("Countries", async e =>
+            return _cache.GetOrCreate("Countries", e =>
             {
-                e.SetOptions(new MemoryCacheEntryOptions
-                {
+                e.SetOptions(new MemoryCacheEntryOptions {
                     AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(24)
                 });
 
                 try
                 {
-                    var countries = await Task.FromResult(MockUtil.Countries(5));
+                    var countries = GenerateCountries(5);
                     return countries.OrderBy(c => c.CountryName);
                 }
                 catch (Exception ex)
@@ -66,20 +44,24 @@ public async Task<IEnumerable<Country>> GetCountriesAsync()
             });
         }
 
-        public async Task<IEnumerable<Product>> GetProductsAsync(int count)
+        static List<Country> GenerateCountries(int count)
         {
-            var products = new List<Product>();
+            var countries = new Faker<Country>()
+                .RuleFor(o => o.CountryId, f => f.IndexFaker + 1)
+                .RuleFor(o => o.CountryName, f => f.Address.Country())
+                .RuleFor(o => o.CountryCode, f => f.Address.CountryCode())
+                .Generate(count);
 
-            try
+            if (countries.Exists(c => c.CountryName == "Australia"))
             {
-                products = MockUtil.Products(count);
+                countries.Single(c => c.CountryName == "Australia").CountryCode = "AU";
             }
-            catch (Exception ex)
+            else
             {
-                _logger.LogError("GetProductsAsync Error {ex}", ex);
+                countries.Add(new Country { CountryId = count + 1, CountryCode = "AU", CountryName = "Australia" });
             }
 
-            return await Task.FromResult(products);
+            return countries;
         }
     }
 }

MockMe.API/Shared/technologies.json

@@ -1,9 +1,10 @@
-using System;
+using Bogus;
+using MockMe.Common;
+using MockMe.Model;
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Threading.Tasks;
-using MockMe.Common;
-using MockMe.Model;
 
 namespace MockMe.Repository
 {
@@ -14,26 +15,15 @@ public interface ITradeRepository
         Task<AssetTrade> UpdateAsync(Guid id, AssetTrade entity);
         Task<AssetTrade> DeleteAsync(Guid id);
         Task<AssetTrade> GenerateAsync();
-
-        List<CurrencyPair> CurrencyPairList();
     }
 
     public class TradeRepository : ITradeRepository
     {
-        private static List<CurrencyPair> CurrencyPairs;
-        private static List<AssetTrade> Trades;
+        static List<AssetTrade> Trades;
 
         public TradeRepository()
         {
-            if (CurrencyPairs == null)
-            {
-                CurrencyPairs = MockUtil.CurrencyPairs.ToList();
-            }
-
-            if (Trades == null)
-            {
-                Trades = MockUtil.Trades(10);
-            }
+            Trades ??= GenerateTrades(10);
         }
 
         public async Task<IEnumerable<AssetTrade>> GetAllAsync()
@@ -69,13 +59,25 @@ public async Task<AssetTrade> DeleteAsync(Guid id)
 
         public async Task<AssetTrade> GenerateAsync()
         {
-            var randomTrade = MockUtil.Trades(1).FirstOrDefault();
+            var randomTrade = GenerateTrades(1).FirstOrDefault();
             return await Task.FromResult(randomTrade);
         }
 
-        public List<CurrencyPair> CurrencyPairList()
+        List<AssetTrade> GenerateTrades(int count)
         {
-            return CurrencyPairs;
+            var currencyPairs = ((IEnumerable<CurrencyPair>)Enum.GetValues(typeof(CurrencyPair))).ToList();
+            var trades = new Faker<AssetTrade>()
+                .RuleFor(o => o.Id, f => Guid.NewGuid().ToString())
+                .RuleFor(o => o.Asset, f => {
+                    var pair = new Faker().Random.ListItem((IList<CurrencyPair>)currencyPairs);
+                    return new Asset((int)pair, pair.Description());
+                })
+                .RuleFor(o => o.Amount, f => decimal.Parse(f.Random.Decimal(1000).ToString("0.00")))
+                .RuleFor(o => o.Expiration, f => f.Random.Number(1, 1000))
+                .RuleFor(o => o.Payout, f => f.Random.Number(1, 1000))
+                .RuleFor(o => o.Direction, f => f.Random.Number(0, 1))
+                .Generate(count);
+            return trades;
         }
     }
 }