Feature repricing min max (#10)

amazon settlement import/export improvements

src/bnhtrade.Core/Logic/Product/GetCompetitivePrice.cs

@@ -0,0 +1,261 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace bnhtrade.Core.Logic.Product
+{
+    public class GetCompetitivePrice
+    {
+        private Dictionary<string, Model.Product.CompetitivePrice> competitivePrices;
+        private int newConditionId = Data.Database.Constants.GetProductConditionIdNew();
+        private string sqlConnectionString;
+        private Data.Database.Product.ReadCompetitivePrice read;
+        private List<string> productIdList;
+        private List<string> conditionIdList;
+        private Data.Database.Product.ReadCompetitivePrice dbRead;
+        private Dictionary<int, decimal> newConditionMultipier;
+
+        public GetCompetitivePrice(string sqlConnectionString)
+        {
+            this.sqlConnectionString = sqlConnectionString;
+            dbRead = new Data.Database.Product.ReadCompetitivePrice(sqlConnectionString);
+            newConditionMultipier = new Dictionary<int, decimal>();
+        }
+
+        /// <summary>
+        /// If a competitive price for a used condition is not found, return an estimated figure.
+        /// </summary>
+        public bool EstimatePrice { get; set; } = false;
+
+        public int DistinctRequestCount { get; private set; } = 0;
+
+        public int DistinctResponceCount { get; private set; } = 0;
+
+        public void Innit()
+        {
+            DistinctRequestCount = 0;
+            DistinctResponceCount = 0;
+        }
+
+        public Dictionary<string, Model.Product.CompetitivePrice> Execute(List<Model.Sku.Price.SkuPriceParameter> skuParamList)
+        {
+            var requestList = new List<(int ProductId, int ConditionId)>();
+            for (int i = 0; i < skuParamList.Count; i++)
+            {
+                requestList.Add((skuParamList[i].ProductId, skuParamList[i].ConditionId));
+            }
+            var result = Execute(requestList);
+
+            // build return list
+            var returnList = new Dictionary<string, Model.Product.CompetitivePrice>();
+            for (int i = 0; i < skuParamList.Count; i++)
+            {
+                // skip?
+                if (returnList.ContainsKey(skuParamList[i].SkuNumber))
+                {
+                    continue;
+                }
+                // make a match
+                for (int j = 0; j < result.Count; j++)
+                {
+                    if (skuParamList[i].ProductId == result[j].ProductId && skuParamList[i].ConditionId == result[j].ConditionId)
+                    {
+                        returnList.Add(skuParamList[i].SkuNumber, result[j].Clone());
+                        break;
+                    }
+                }
+            }
+            return returnList;
+        }
+
+        public List<Model.Product.CompetitivePrice> Execute(List<(int ProductId, int ConditionId)> requestList)
+        {
+            Innit();
+
+            var result = new List<Model.Product.CompetitivePrice>();
+
+            if (requestList == null || !requestList.Any())
+            {
+                return result;
+            }
+
+            // build distinct list
+            var distinctRequestList = new List<(int productId, int conditionId)>();
+            for (int i = 0; i < requestList.Count; i++)
+            {
+                // filter values already requested
+                bool distinct = true;
+                for (int j = 0; j < distinctRequestList.Count; j++)
+                {
+                    if (requestList[i].ProductId == distinctRequestList[j].productId
+                        && requestList[i].ConditionId == distinctRequestList[j].conditionId)
+                    {
+                        distinct = false;
+                        break;
+                    }
+                }
+                if (distinct)
+                { distinctRequestList.Add((requestList[i].ProductId, requestList[i].ConditionId)); }
+            }
+
+            DistinctRequestCount = distinctRequestList.Count();
+            var dbResult = dbRead.Execute(distinctRequestList);
+
+            // only contiue if estimated values are retured
+            if (DistinctRequestCount == dbResult.Count || !EstimatePrice)
+            {
+                DistinctResponceCount = dbResult.Count;
+                return result;
+            }
+
+            // build estimated list
+            var estimatedRequestList = new List<(int productId, int conditionId)>();
+            //var conditionMultipier = new Dictionary<int, decimal>();
+            for (int i = 0; i < distinctRequestList.Count; i++)
+            {
+                bool request = true;
+                // check if db returned record
+                for (int j = 0; j < dbResult.Count; j++)
+                {
+                    if (distinctRequestList[i].productId == dbResult[j].ProductId
+                        && distinctRequestList[i].conditionId == dbResult[j].ConditionId)
+                    {
+                        request = false;
+                        break;
+                    }
+                }
+                // check if 'new' condition price has already been retrived
+                if (request)
+                {
+                    for (int j = 0; j < dbResult.Count; j++)
+                    {
+                        if (distinctRequestList[i].productId == dbResult[j].ProductId
+                            && dbResult[j].ConditionId == newConditionId)
+                        {
+                            request = false;
+                            break;
+                        }
+                    }
+                }
+                // add to request lists
+                if (request)
+                {
+                    estimatedRequestList.Add((distinctRequestList[i].productId, newConditionId));
+                    if (!newConditionMultipier.ContainsKey(distinctRequestList[i].conditionId))
+                    {
+                        newConditionMultipier.Add(distinctRequestList[i].conditionId, -1);
+                    }
+                }
+            }
+
+            dbResult.AddRange(dbRead.Execute(estimatedRequestList));
+            UpdateConditionMultipers();
+
+            // build a new return list
+            var newResult = new List<Model.Product.CompetitivePrice>();
+            var noMatchList = new List<(int productId, int conditionId)>();
+            for (int i = 0; i < distinctRequestList.Count; i++)
+            {
+                // add exact matches
+                bool noMatch = true;
+                for (int j = 0; j < dbResult.Count; j++)
+                {
+                    if (distinctRequestList[i].productId == dbResult[j].ProductId
+                        && distinctRequestList[i].conditionId == dbResult[j].ConditionId)
+                    {
+                        noMatch = false;
+                        newResult.Add(dbResult[j]);
+                        break;
+                    }
+                }
+                // add estimated matches
+                if (noMatch)
+                {
+                    for (int j = 0; j < dbResult.Count; j++)
+                    {
+                        if (distinctRequestList[i].productId == dbResult[j].ProductId
+                            && dbResult[j].ConditionId == newConditionId)
+                        {
+                            if (!newConditionMultipier.ContainsKey(distinctRequestList[i].conditionId))
+                            {
+                                break;
+                            }
+
+                            var clone = dbResult[j].Clone();
+                            clone.ConditionId = distinctRequestList[i].conditionId;
+                            clone.Price = decimal.Round(clone.Price * newConditionMultipier[distinctRequestList[i].conditionId], 2);
+                            clone.PriceIsEstimated = true;
+
+                            newResult.Add(clone);
+                            noMatch = false;
+                            break;
+                        }
+                    }
+                }
+                if (noMatch)
+                {
+                    noMatchList.Add(distinctRequestList[i]);
+                }
+            }
+
+            DistinctResponceCount = newResult.Count;
+            return newResult;
+        }
+
+        public Model.Product.CompetitivePrice Execute(int productId, int conditionId)
+        {
+            Innit();
+            DistinctRequestCount = 1;
+            var result = dbRead.Execute(new List<(int, int)> { (productId, conditionId) });
+
+            if (!result.Any())
+            {
+                DistinctResponceCount = 0;
+                return null;
+            }
+            else
+            {
+                DistinctResponceCount = 1;
+                return result.First(); 
+            }
+        }
+
+        private void UpdateConditionMultipers()
+        {
+            var conditionInfo = new List<Model.Sku.SkuConditionInfo>();
+
+            if (newConditionMultipier.Any())
+            {
+                conditionInfo = new Logic.Sku.GetSkuConditionInfo(sqlConnectionString)
+                    .GetByConditionId(newConditionMultipier.Keys.ToList());
+            }
+            else
+            {
+                conditionInfo = new Logic.Sku.GetSkuConditionInfo(sqlConnectionString).GetAll();
+            }
+            
+            for(int i = 0; i < conditionInfo.Count; i++)
+            {
+                if (newConditionMultipier.ContainsKey(conditionInfo[i].SkuConditionId))
+                {
+                    newConditionMultipier[conditionInfo[i].SkuConditionId] = conditionInfo[i].CompetitivePriceMultiplier;
+                }
+                else
+                {
+                    throw new Exception("Condition Id mismatch");
+                }
+            }
+
+            // check all multipilers have been set
+            for (int i = 0; i < newConditionMultipier.Count; i++)
+            {
+                if (newConditionMultipier.ElementAt(i).Value <= 0)
+                {
+                    throw new Exception("Invalid price multiplier");
+                }
+            }
+        }
+    }
+}