Feature repricing min max (#10)

amazon settlement import/export improvements

src/bnhtrade.Core/Data/Database/Stock/CreateSkuTransaction.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace bnhtrade.Core.Data.Database.Stock
+{
+    public class CreateSkuTransaction : Connection
+    {
+        public CreateSkuTransaction(string sqlConnectionString) : base(sqlConnectionString)
+        {
+        }
+
+        public void Create(Model.Stock.SkuTransaction skuTransaction)
+        {
+            using (var conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                using (SqlCommand cmd = new SqlCommand(@"
+                    INSERT INTO tblStockSkuTransaction (
+	                    TransactionDate
+	                    ,StockSkuTransactionTypeID
+	                    ,ForeignKey
+	                    ,Reference
+	                    ,Detail
+	                    ,SkuID
+	                    ,Quantity
+	                    ,IsProcessed
+	                    ,StockJournalID
+	                    )
+                    OUTPUT INSERTED.StockSkuTransactionID
+                    VALUES (
+	                    @transactionDate
+	                    ,@stockSkuTransactionTypeID
+	                    ,@foreignKey
+	                    ,@reference
+	                    ,@Detail
+	                    ,(
+		                    SELECT skuSkuID
+		                    FROM tblSku
+		                    WHERE skuSkuNumber = @skuNumber
+		                    )
+	                    ,@quantity
+	                    ,@isProcessed
+	                    ,@stockJournalID
+	                    )
+                    ", conn))
+                {
+                    cmd.Parameters.AddWithValue("@transactionDate", skuTransaction.TransactionDate.ToUniversalTime());
+                    cmd.Parameters.AddWithValue("@stockSkuTransactionTypeID", skuTransaction.SkuTransactionTypeId);
+                    if (!skuTransaction.IsSetForeignKey) { cmd.Parameters.AddWithValue("@foreignKey", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@foreignKey", skuTransaction.ForeignKey); }
+                    if (!skuTransaction.IsSetReference) { cmd.Parameters.AddWithValue("@reference", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@reference", skuTransaction.Reference); }
+                    if (!skuTransaction.IsSetDetail) { cmd.Parameters.AddWithValue("@detail", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@detail", skuTransaction.Detail); }
+                    cmd.Parameters.AddWithValue("@skuNumber", skuTransaction.SkuNumber);
+                    cmd.Parameters.AddWithValue("@quantity", skuTransaction.Quantity);
+                    cmd.Parameters.AddWithValue("@isProcessed", skuTransaction.IsProcessed);
+                    if (!skuTransaction.IsSetStockJournalId) { cmd.Parameters.AddWithValue("@stockJournalID", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@stockJournalID", skuTransaction.StockJournalId); }
+
+                    object obj = cmd.ExecuteScalar();
+
+                    if (obj == null || obj == DBNull.Value)
+                    {
+                        throw new Exception("Sku Reconcile Transaction insert failed");
+                    }
+
+                    skuTransaction.SkuTransactionId = (int)obj;
+                }
+            }
+        }
+    }
+}

src/bnhtrade.Core/Data/Database/Stock/DeleteSkuTransaction.cs

@@ -0,0 +1,36 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace bnhtrade.Core.Data.Database.Stock
+{
+    public class DeleteSkuTransaction : Connection
+    {
+        public DeleteSkuTransaction (string sqlConnectionString): base(sqlConnectionString)
+        {
+        }
+
+        public void ByTransactionId(int skuReconcileId)
+        {
+            using (var conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                using (SqlCommand cmd = new SqlCommand(@"
+                    DELETE FROM tblStockSkuTransaction WHERE StockSkuTransactionID = @transactionId
+                    ", conn))
+                {
+                    cmd.Parameters.AddWithValue("@transactionId", skuReconcileId);
+
+                    if (cmd.ExecuteNonQuery() < 1)
+                    {
+                        throw new Exception("Delete sku transaction effected no records");
+                    }
+                }
+            }
+        }
+    }
+}

src/bnhtrade.Core/Data/Database/Stock/ReadSkuTransaction.cs

@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Dapper;
+
+namespace bnhtrade.Core.Data.Database.Stock
+{
+    public class ReadSkuTransaction : Connection
+    {
+        public ReadSkuTransaction(string sqlConnectionString) : base(sqlConnectionString)
+        {
+
+        }
+
+        public int? GetJournalId(int skuTransactionId)
+        {
+            using (var conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                using (var cmd = new SqlCommand(@"
+                    SELECT StockJournalID FROM tblStockSkuTransaction WHERE StockSkuTransactionID=@transactionId
+                    ", conn))
+                {
+                    cmd.Parameters.AddWithValue("@transactionId", skuTransactionId);
+
+                    object obj = cmd.ExecuteScalar();
+
+                    if (obj == null || obj == DBNull.Value)
+                    {
+                        return null;
+                    }
+                    else
+                    {
+                        return (int)obj;
+                    }
+                }
+            }
+        }
+
+        public List<Model.Stock.SkuTransaction> GetUnreconciled()
+        {
+            // order by stocktransId desc = Amazon reports are listed in datetime ASC order, some reports have date only, 
+            // however I have reason to believe these are in time order.
+            // Adding this means they at least get processed in the correct order (maybe)!
+            string sqlWhere = @"
+                WHERE tblStockSkuTransaction.IsProcessed = 0
+	                AND (
+		                tblStockSkuTransactionType.StockJournalEntryEnabled = 1
+		                OR tblStockSkuTransactionType.IsNewReviewRequired = 1
+		                ) ";
+
+            return Read(sqlWhere, new DynamicParameters());
+        }
+
+        private List<Model.Stock.SkuTransaction> Read(string sqlWhere, DynamicParameters parameters)
+        {
+            var resultList = new List<Model.Stock.SkuTransaction>();
+
+            string sql = @"
+                SELECT tblStockSkuTransaction.StockSkuTransactionID AS SkuTransactionId
+	                ,tblStockSkuTransaction.TransactionDate
+	                ,tblStockSkuTransaction.StockSkuTransactionTypeID AS SkuTransactionTypeId
+	                ,tblStockSkuTransaction.ForeignKey
+	                ,tblStockSkuTransaction.Reference
+	                ,tblStockSkuTransaction.Detail
+	                ,tblStockSkuTransaction.Quantity
+                    ,tblStockSkuTransaction.IsProcessed
+                    ,tblStockSkuTransaction.StockJournalID AS StockJournalId
+                    ,tblStockSkuTransactionType.TypeTitle AS SkuTransactionTypeName
+	                ,tblSku.skuSkuNumber AS SkuNumber
+	                ,tblStockSkuTransaction.SkuID
+                FROM tblStockSkuTransaction
+                INNER JOIN tblStockSkuTransactionType ON tblStockSkuTransaction.StockSkuTransactionTypeID = tblStockSkuTransactionType.StockSkuTransactionTypeID
+                INNER JOIN tblSku ON tblStockSkuTransaction.SkuID = tblSku.skuSkuID ";
+            
+            sql += sqlWhere;
+
+            sql += @"
+                ORDER BY tblStockSkuTransaction.TransactionDate ASC, tblStockSkuTransaction.StockSkuTransactionID DESC;";
+
+            using (SqlConnection conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                resultList = conn.Query<Model.Stock.SkuTransaction>(sql, parameters).ToList();
+            }
+
+            // set datetime kind
+            for (int i = 0; i < resultList.Count; i++)
+            {
+                if (resultList[i].IsSetTransactionDate)
+                {
+                    resultList[i].TransactionDate = DateTime.SpecifyKind(resultList[i].TransactionDate, DateTimeKind.Utc);
+                }
+            }
+
+            return resultList;
+        }
+    }
+}

src/bnhtrade.Core/Data/Database/Stock/ReadSkuTransactionType.cs

@@ -0,0 +1,153 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Dapper;
+
+namespace bnhtrade.Core.Data.Database.Stock
+{
+    public class ReadSkuTransactionType : Connection
+    {
+        public ReadSkuTransactionType(string sqlConnectionString) : base(sqlConnectionString)
+        {
+        }
+
+        /// <summary>
+        /// Depriciated, delete when not required by other code
+        /// </summary>
+        /// <param name="sqlConnectionString"></param>
+        /// <param name="typeCode"></param>
+        /// <returns></returns>
+        public int GetTypeId(string typeCode)
+        {
+            /* GetStockTransactionTypeId return meanings
+            * >0       use the as the TypeId when inserting transaction
+            *  0       Skip transpose, type doesn't exist or is new (not reviewed yet)
+            * -1       Type import/transpose is disabled, IsProcessed=TRUE StockTransactionID=NULL */
+
+            // old optional parameters
+            // , bool onNewReturnId = false, bool onNewDisableInsert = false
+
+            if (typeCode.Length == 0)
+            {
+                throw new Exception("Empty match string passed to method");
+            }
+            using (SqlConnection sqlConn = new SqlConnection(sqlConnectionString))
+            {
+                sqlConn.Open();
+                using (SqlCommand cmd = new SqlCommand(@"
+                        SELECT 
+                            StockSkuTransactionTypeID, 
+                            IsNewReviewRequired, 
+                            TransactionImportEnabled 
+                        FROM 
+                            tblStockSkuTransactionType 
+                        WHERE 
+                            TypeCode=@typeCode;
+                        ", sqlConn))
+                {
+                    cmd.Parameters.AddWithValue("@typeCode", typeCode);
+
+                    using (SqlDataReader reader = cmd.ExecuteReader())
+                    {
+                        if (reader.Read())
+                        {
+                            int index01 = reader.GetOrdinal("StockSkuTransactionTypeID");
+                            int index02 = reader.GetOrdinal("IsNewReviewRequired");
+                            int index03 = reader.GetOrdinal("TransactionImportEnabled");
+
+                            int transactionTypeId = reader.GetInt32(index01);
+                            bool isNew = reader.GetBoolean(index02);
+                            bool? importEnabled = reader[index03] as bool? ?? null;  // column can be null
+
+                            if (isNew == true || importEnabled == null)
+                            {
+                                // return 0 and 'skip' item
+                                return 0;
+                            }
+                            else if (importEnabled == false)
+                            {
+                                // mark IsProcessed=true and leave transactionId=null 
+                                return -1;
+                            }
+                            else if (transactionTypeId > 0)
+                            {
+
+                                return transactionTypeId;
+                            }
+                            else
+                            {
+                                throw new Exception("Sku TransactionTypeId lookup method failed, is one of the 'enabled' boolean on table set to null?");
+                            }
+                        }
+                        else
+                        {
+                            return 0;
+                        }
+                    }
+                }
+            }
+        }
+
+        private List<Model.Stock.SkuTransactionType> Execute(string sqlWhere, DynamicParameters param)
+        {
+            string sql = @"
+                SELECT tblStockSkuTransactionType.StockSkuTransactionTypeID AS TypeId
+	                ,tblStockSkuTransactionType.TypeName
+	                ,tblStockSkuTransactionType.TypeCode
+	                ,tblStockSkuTransactionType.TypeDescription
+	                ,tblStockSkuTransactionType.StockJournalTypeID
+	                ,tblStockSkuTransactionType.TransactionForeignKeyName
+	                ,tblStockSkuTransactionType.TransactionReferenceType
+	                ,tblStockSkuTransactionType.IsNewReviewRequired
+	                ,tblStockSkuTransactionType.TransactionImportEnabled
+	                ,tblStockSkuTransactionType.StockJournalEntryEnabled
+	                ,tblStockSkuTransactionType.DebitStockStatusID
+	                ,tblStockSkuTransactionType.CreditStockStatusID
+	                ,tblStockSkuTransactionType.StatusBalanceCheckRequired
+	                ,tblStockSkuTransactionType.FilterStockOnDateTime
+	                ,tblStockSkuTransactionType.FirstInFirstOut
+	                ,tblStockSkuTransactionType.RecordCreated
+	                ,CreditStatus.StockStatus AS CreditStockStatus
+	                ,DebitStatus.StockStatus AS DebitStockStatus
+                FROM tblStockStatus AS DebitStatus
+                RIGHT OUTER JOIN tblStockSkuTransactionType ON DebitStatus.StockStatusID = tblStockSkuTransactionType.DebitStockStatusID
+                LEFT OUTER JOIN tblStockStatus AS CreditStatus ON tblStockSkuTransactionType.CreditStockStatusID = CreditStatus.StockStatusID
+                ";
+
+            sql += sqlWhere;
+
+            using (SqlConnection conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                return conn.Query<Model.Stock.SkuTransactionType>(sql, param).ToList();
+            }
+        }
+
+        public List<Model.Stock.SkuTransactionType> ByTypeCode(List<string> typeCode)
+        {
+            string sqlWhere = @"
+                WHERE TypeCode IN @typeCode ";
+
+            var param = new DynamicParameters();
+            param.Add("@typeCode", typeCode);
+
+            return Execute(sqlWhere, param);
+        }
+
+        public List<Model.Stock.SkuTransactionType> ByTypeName(List<string> typeName)
+        {
+            string sqlWhere = @"
+                WHERE TypeName IN @typeName ";
+
+            var param = new DynamicParameters();
+            param.Add("@typeName", typeName);
+
+            return Execute(sqlWhere, param);
+        }
+
+    }
+}

src/bnhtrade.Core/Data/Database/Stock/UpdateSkuTransaction.cs

@@ -0,0 +1,198 @@
+using System;
+using System.Collections.Generic;
+using System.Data.SqlClient;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace bnhtrade.Core.Data.Database.Stock
+{
+    public class UpdateSkuTransaction : Connection
+    {
+        private string err = "Database UpdateSkuTransaction: ";
+
+        public UpdateSkuTransaction(string sqlConnectionString) : base(sqlConnectionString)
+        {
+        }
+
+        public void Update(int skuTransactionId, bool isProcessed)
+        {
+            using (var conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                using (SqlCommand cmd = new SqlCommand(@"
+                    UPDATE tblStockSkuTransaction 
+                    SET IsProcessed=@isProcessed
+                    WHERE StockSkuTransactionID=@transactionId
+                    ", conn))
+                {
+                    cmd.Parameters.AddWithValue("@isProcessed", isProcessed);
+                    cmd.Parameters.AddWithValue("@transactionId", skuTransactionId);
+
+                    int effected = cmd.ExecuteNonQuery();
+
+                    if (effected < 1)
+                    {
+                        throw new Exception(err += "Sku Transaction IsProcessed update failed");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Update the StockJournalID field. Will also set the IsProcessed value base on input.
+        /// </summary>
+        /// <param name="skuTransactionId">Sku Transaction Id</param>
+        /// <param name="stockJournalId">Stock Journal Id or null to unset</param>
+        public void Update(int skuTransactionId, int? stockJournalId)
+        {
+            string sql = @"
+                    UPDATE tblStockSkuTransaction
+                    SET IsProcessed = @isProcessed
+	                    ,StockJournalID = @stockJournalID 
+                    WHERE StockSkuTransactionID = @transactionId;";
+
+            using (var conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    if (stockJournalId == null) { cmd.Parameters.AddWithValue("@stockJournalID", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@stockJournalID", (int)stockJournalId); }
+                    if (stockJournalId == null) { cmd.Parameters.AddWithValue("@isProcessed", false); }
+                    else { cmd.Parameters.AddWithValue("@isProcessed", true); }
+                    cmd.Parameters.AddWithValue("@transactionId", skuTransactionId);
+
+                    int effected = cmd.ExecuteNonQuery();
+
+                    if (effected < 1)
+                    {
+                        throw new Exception(err += "Sku Transaction StockJournalID update failed");
+                    }
+                }
+            }
+        }
+
+        public void Update(int skuTransactionId, int quantity, bool isProcessed)
+        {
+            string sql = @"
+                    UPDATE tblStockSkuTransaction
+                    SET IsProcessed = @isProcessed
+	                    ,Quantity = @quantity 
+                    WHERE StockSkuTransactionID = @transactionId;";
+
+            using (var conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    cmd.Parameters.AddWithValue("@isProcessed", isProcessed);
+                    cmd.Parameters.AddWithValue("@quantity", quantity);
+                    cmd.Parameters.AddWithValue("@transactionId", skuTransactionId);
+
+                    int effected = cmd.ExecuteNonQuery();
+
+                    if (effected < 1)
+                    {
+                        throw new Exception(err += "Sku Transaction quantity and isprocessed update failed");
+                    }
+                }
+            }
+        }
+
+        /// <summary>
+        /// Update the StockJournalID field. Will also set the IsProcessed value base on input.
+        /// </summary>
+        /// <param name="skuTransactionId">Sku Transaction Id</param>
+        /// <param name="quantity">Sku Transaction quantity. Set to null to leave database value unchanged.</param>
+        /// <param name="stockJournalId">Stock Journal Id</param>
+        public void Update(int skuTransactionId, int? quantity, int stockJournalId)
+        {
+            string sql = @"
+                    UPDATE tblStockSkuTransaction
+                    SET IsProcessed = @isProcessed
+	                    ,StockJournalID = @stockJournalID ";
+
+            if (quantity != null)
+            {
+                sql += @"
+                    ,Quantity = @quantity ";
+            }
+
+            sql += @"
+                    WHERE StockSkuTransactionID = @transactionId;";
+
+            using (var conn = new SqlConnection(sqlConnectionString))
+            {
+                conn.Open();
+
+                using (SqlCommand cmd = new SqlCommand(sql, conn))
+                {
+                    if (quantity != null) { cmd.Parameters.AddWithValue("@quantity", (int)quantity); }
+                    cmd.Parameters.AddWithValue("@isProcessed", true);
+                    cmd.Parameters.AddWithValue("@stockJournalID", stockJournalId);
+                    cmd.Parameters.AddWithValue("@transactionId", skuTransactionId);
+
+                    int effected = cmd.ExecuteNonQuery();
+
+                    if (effected < 1)
+                    {
+                        throw new Exception(err += "Sku Transaction IsProcessed update failed");
+                    }
+                }
+            }
+        }
+
+        public void Update(Model.Stock.SkuTransaction skuTransaction)
+        {
+            using (var conn = new SqlConnection())
+            {
+                conn.Open();
+
+                using (SqlCommand cmd = new SqlCommand(@"
+                    UPDATE tblStockSkuTransaction
+                    SET TransactionDate = @transactionDate
+	                    ,StockSkuTransactionTypeID = @stockSkuTransactionTypeID
+	                    ,ForeignKey = @foreignKey
+	                    ,Reference = @reference
+	                    ,Detail = @Detail
+	                    ,SkuID = (
+		                    SELECT skuSkuID
+		                    FROM tblSku
+		                    WHERE skuSkuNumber = @skuNumber
+		                    )
+	                    ,Quantity = @quantity
+	                    ,IsProcessed = @isProcessed
+	                    ,StockJournalID = @stockJournalID
+                    WHERE StockSkuTransactionID = @transactionId
+                    ", conn))
+                {
+                    cmd.Parameters.AddWithValue("@transactionDate", skuTransaction.TransactionDate.ToUniversalTime());
+                    cmd.Parameters.AddWithValue("@stockSkuTransactionTypeID", skuTransaction.SkuTransactionTypeId);
+                    if (!skuTransaction.IsSetForeignKey) { cmd.Parameters.AddWithValue("@foreignKey", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@foreignKey", skuTransaction.ForeignKey); }
+                    if (!skuTransaction.IsSetReference) { cmd.Parameters.AddWithValue("@reference", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@reference", skuTransaction.Reference); }
+                    if (!skuTransaction.IsSetDetail) { cmd.Parameters.AddWithValue("@detail", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@detail", skuTransaction.Detail); }
+                    cmd.Parameters.AddWithValue("@skuNumber", skuTransaction.SkuNumber);
+                    cmd.Parameters.AddWithValue("@quantity", skuTransaction.Quantity);
+                    cmd.Parameters.AddWithValue("@isProcessed", skuTransaction.IsProcessed);
+                    if (!skuTransaction.IsSetStockJournalId) { cmd.Parameters.AddWithValue("@stockJournalID", DBNull.Value); }
+                    else { cmd.Parameters.AddWithValue("@stockJournalID", skuTransaction.StockJournalId); }
+                    cmd.Parameters.AddWithValue("@transactionId", skuTransaction.SkuTransactionId);
+
+                    int effected = cmd.ExecuteNonQuery();
+
+                    if (effected < 1)
+                    {
+                        throw new Exception(err += "stockSkuTransaction IsProcessed update failed");
+                    }
+                }
+            }
+        }
+    }
+}