bobbie/bnhtrade
1
0
Fork 0
mirror of https://github.com/stokebob/bnhtrade.git synced 2026-03-19 06:27:15 +00:00
Code Issues Packages Projects Releases Wiki Activity

SP-API stock reconciliation

Browse Source 
Amazon had depreciated a number of reports that were used for stock reconciliation. Application now uses the new fba ledger report to reconcile. It is currently untested, as this requires data from Amazon. Methods that require testing will return a 'NotImplementedException'.

Also, removed the depreciated ILMerge and replaced with ILRepack.

Plus much more tidying up, and improvements.
This commit is contained in:
Bobbie Hodgetts
2024-05-07 08:24:00 +01:00
committed by GitHub
parent 2f919d7b5a
commit 91ef9acc78
1272 changed files with 4944 additions and 2773311 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
src/bnhtrade.Core/Data/Database/Stock/CreateSkuTransaction.cs → src/bnhtrade.Core/Data/Database/Stock/InsertSkuTransaction.cs
View File

@@ -7,13 +7,16 @@ using System.Threading.Tasks;
namespace bnhtrade.Core.Data.Database.Stock
{
public class CreateSkuTransaction : Connection
public class InsertSkuTransaction : Connection
{
public CreateSkuTransaction()
/// <summary>
/// Not to be used directly, all CRUD operation should be accessed via the logic layer implementation
/// </summary>
public InsertSkuTransaction()
{
}
public void Create(Model.Stock.SkuTransaction skuTransaction)
public int Insert(Model.Stock.SkuTransactionCreate skuTransaction)
{
using (var conn = new SqlConnection(SqlConnectionString))
{
@@ -55,17 +58,16 @@ namespace bnhtrade.Core.Data.Database.Stock
{
cmd.Parameters.AddWithValue("@transactionDate", skuTransaction.TransactionDate.ToUniversalTime());
cmd.Parameters.AddWithValue("@skuTransactionTypeCode", skuTransaction.SkuTransactionTypeCode);
if (!skuTransaction.IsSetForeignKey) { cmd.Parameters.AddWithValue("@foreignKey", DBNull.Value); }
if (skuTransaction.ForeignKey == null) { cmd.Parameters.AddWithValue("@foreignKey", DBNull.Value); }
else { cmd.Parameters.AddWithValue("@foreignKey", skuTransaction.ForeignKey); }
if (!skuTransaction.IsSetReference) { cmd.Parameters.AddWithValue("@reference", DBNull.Value); }
if (skuTransaction.Reference == null) { cmd.Parameters.AddWithValue("@reference", DBNull.Value); }
else { cmd.Parameters.AddWithValue("@reference", skuTransaction.Reference); }
if (!skuTransaction.IsSetDetail) { cmd.Parameters.AddWithValue("@detail", DBNull.Value); }
if (skuTransaction.Detail == null) { 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("@isProcessed", false);
cmd.Parameters.AddWithValue("@stockJournalID", DBNull.Value);
object obj = cmd.ExecuteScalar();
@@ -74,7 +76,8 @@ namespace bnhtrade.Core.Data.Database.Stock
throw new Exception("Sku Reconcile Transaction insert failed");
}
skuTransaction.SkuTransactionId = (int)obj;
int transactionId = (int)obj;
return transactionId;
}
}
}

65
src/bnhtrade.Core/Data/Database/Stock/InsertSkuTransactionType.cs Normal file
View File

@@ -0,0 +1,65 @@
using System;
using System.Data.SqlClient;
using System.Transactions;
namespace bnhtrade.Core.Data.Database.Stock
{
public class InsertSkuTransactionType : Connection
{
/// <summary>
/// The insert command will not participate in any amibent transaction scope. Default is true.
/// </summary>
public bool SuppressTransactionScope { get; set; } = true;
/// <summary>
/// Creates a new SKU Transaction Type
/// </summary>
/// <param name="stockJournalTypeId"></param>
/// <param name="skuTransactionCode"></param>
/// <returns>ID of the created record</returns>
/// <exception cref="Exception"></exception>
public int Create(string skuTransactionCode, int stockJournalTypeId)
{
int id;
var scopeOption = new TransactionScopeOption();
if (SuppressTransactionScope)
{
scopeOption = TransactionScopeOption.Suppress;
}
else
{
scopeOption = TransactionScopeOption.Required;
}
using (TransactionScope scope = new TransactionScope(scopeOption))
using (SqlConnection conn = new SqlConnection(SqlConnectionString))
{
conn.Open();
// insert new and retrive new value
using (SqlCommand cmd = new SqlCommand(@"
INSERT INTO tblStockSkuTransactionType
( TypeName, StockJournalTypeID, TypeCode )
OUTPUT
INSERTED.StockSkuTransactionTypeID
VALUES
( @typeName, @stockJournalTypeId, @typeCode );
", conn))
{
cmd.Parameters.AddWithValue("@typeName", skuTransactionCode);
cmd.Parameters.AddWithValue("@typeCode", skuTransactionCode);
cmd.Parameters.AddWithValue("@stockJournalTypeId", stockJournalTypeId);
object obj = cmd.ExecuteScalar();
if (obj == null || obj == DBNull.Value)
throw new Exception("tblStockSkuTransactionType insert operation returned null");
id = (int)obj;
}
scope.Complete();
}
return id;
}
}
}

602
src/bnhtrade.Core/Data/Database/Stock/JournalCrud.cs Normal file
View File

@@ -0,0 +1,602 @@
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;
namespace bnhtrade.Core.Data.Database.Stock
{
public class JournalCrud : Connection
{
// only to be assessable via code, use stock relocate to move stock bewtween status'
public int StockJournalInsert(int journalTypeId, int stockId, List<(int statusId, int quantity)> journalPosts,
DateTime entryDate, bool isNewStock = false)
{
/*
* TODO: currently the consistancy check checks the journal after the entry has been inserted to the db, if the check fails
* the transaction scope is disposed, and the ne journal entries roll back. However, if this is done within a higher
* level transaction scope, this nested dispose() also rolls back the all transacopes scopes it is a child of.
*
* Therefore, a consistancy check needs to be simulated in code to negate the need to rollback/dispose of a db transaction.
* This would also have some slight performance benefits.
*
* Once you've done this, fix the SkuTransactionReconcile class: Currently it's transactionscope only covers updates.
* Need to set the scope to cover the intial table read (to lock the records). The issue above restricts this.
*/
// balance and status IsCredit checks made by post insert function
// create the journal entry
int stockJournalId;
using (TransactionScope scope = new TransactionScope())
using (SqlConnection conn = new SqlConnection(SqlConnectionString))
{
conn.Open();
//consitancy check is required?
bool consistencyRequired = true;
// get date of most recent debit for status' that I will be crediting
if (isNewStock == false)
{
// build sql string
string stringSql = @"
SELECT
tblStockJournal.EntryDate
FROM
tblStockJournal
INNER JOIN tblStockJournalPost
ON tblStockJournal.StockJournalID = tblStockJournalPost.StockJournalID
WHERE
tblStockJournal.StockID=@stockId
AND EntryDate>=@entryDate
AND tblStockJournalPost.Quantity>0
AND (";
bool firstDone = false;
foreach (var item in journalPosts)
{
if (item.quantity < 0)
{
if (firstDone)
{
stringSql = stringSql + " OR ";
}
stringSql = stringSql + "tblStockJournalPost.StockStatusID=" + item.statusId;
firstDone = true;
}
}
stringSql = stringSql + ");";
using (SqlCommand cmd = new SqlCommand(stringSql, conn))
{
cmd.Parameters.AddWithValue("@stockId", stockId);
cmd.Parameters.AddWithValue("@entryDate", entryDate.ToUniversalTime());
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
consistencyRequired = true;
}
else
{
consistencyRequired = false;
}
}
}
}
// create journal entry
using (SqlCommand cmd = new SqlCommand(@"
INSERT INTO tblStockJournal ( EntryDate, StockJournalTypeID, StockID, IsLocked )
OUTPUT INSERTED.StockJournalID
VALUES ( @EntryDate, @journalTypeId, @stockID, @isLocked );
", conn))
{
// add parameters
cmd.Parameters.AddWithValue("@stockID", stockId);
cmd.Parameters.AddWithValue("@journalTypeId", journalTypeId);
cmd.Parameters.AddWithValue("@EntryDate", entryDate.ToUniversalTime());
cmd.Parameters.AddWithValue("@isLocked", isNewStock);
//execute
stockJournalId = (int)cmd.ExecuteScalar();
}
// insert journal posts into database
StockJournalPostInsert(conn, stockId, stockJournalId, journalPosts, isNewStock);
// consistency check
bool consistencyResult = true;
if (consistencyRequired)
{
consistencyResult = false;
// build list of effected status'
var statusIdEffected = new List<int>();
foreach (var item in journalPosts)
{
if (item.quantity < 0)
{
statusIdEffected.Add(item.statusId);
}
}
// run check
consistencyResult = StockJournalConsistencyCheck(stockId, statusIdEffected);
}
if (consistencyResult)
{
// commit
scope.Complete();
return stockJournalId;
}
else
{
throw new Exception("Unable to insert stock journal entry, consistancy check failed.");
}
}
}
public void StockJournalDelete(int stockJournalId)
{
using (TransactionScope scope = new TransactionScope())
using (SqlConnection conn = new SqlConnection(SqlConnectionString))
{
conn.Open();
// get date for journal entry
DateTime entryDate;
int stockId;
using (SqlCommand cmd = new SqlCommand(@"
SELECT tblStockJournal.EntryDate, StockID
FROM tblStockJournal
WHERE (((tblStockJournal.StockJournalID)=@stockJournalId));
", conn))
{
// add parameters
cmd.Parameters.AddWithValue("@stockJournalId", stockJournalId);
using (var reader = cmd.ExecuteReader())
{
if (reader.Read())
{
entryDate = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc);
stockId = reader.GetInt32(1);
}
else
{
throw new Exception("StockJournalID=" + stockJournalId + " does not exist!");
}
}
}
// is consistancy check required
bool consistancyCheck;
// build list of debits that are to be deleted
var debitList = new List<int>();
using (SqlCommand cmd = new SqlCommand(@"
SELECT tblStockJournalPost.StockStatusID
FROM tblStockJournalPost
WHERE (((tblStockJournalPost.StockJournalID)=@stockJournalId) AND ((tblStockJournalPost.Quantity)>0));
", conn))
{
// add parameters
cmd.Parameters.AddWithValue("@stockJournalId", stockJournalId);
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
debitList.Add(reader.GetInt32(0));
}
}
else
{
throw new Exception("StockJournalID=" + stockJournalId + " has no debits with quantity greater than zero!");
}
}
}
// check no credits for stockId & debit combination have been made since delete entry
string stringSql = @"
SELECT
tblStockJournal.EntryDate
FROM
tblStockJournal
INNER JOIN tblStockJournalPost
ON tblStockJournal.StockJournalID = tblStockJournalPost.StockJournalID
WHERE
tblStockJournal.StockID=@stockId
AND tblStockJournalPost.Quantity<0
AND EntryDate>=@entryDate
AND (";
bool firstDone = false;
foreach (var item in debitList)
{
if (firstDone)
{
stringSql = stringSql + " OR ";
}
stringSql = stringSql + "tblStockJournalPost.StockStatusID=" + item;
firstDone = true;
}
stringSql = stringSql + ");";
using (SqlCommand cmd = new SqlCommand(stringSql, conn))
{
cmd.Parameters.AddWithValue("@stockId", stockId);
cmd.Parameters.AddWithValue("@entryDate", entryDate.ToUniversalTime());
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
consistancyCheck = true;
}
else
{
consistancyCheck = false;
}
}
}
// delete the posts
StockJournalPostDelete(conn, stockJournalId);
// delete journal entry
using (SqlCommand cmd = new SqlCommand(@"
DELETE FROM tblStockJournal
WHERE StockJournalID=@stockJournalId;
", conn))
{
// add parameters
cmd.Parameters.AddWithValue("@stockJournalId", stockJournalId);
int count = cmd.ExecuteNonQuery();
if (count != 1)
{
throw new Exception("Failed to delete stock journal header.");
}
}
// consistanct check
bool consistencyResult = true;
if (consistancyCheck)
{
// run check
consistencyResult = StockJournalConsistencyCheck(stockId, debitList);
}
if (consistencyResult)
{
// commit
scope.Complete();
}
else
{
throw new Exception("Unable to delete stock journal entry, consistancy check failed.");
}
}
}
private void StockJournalPostInsert(SqlConnection conn, int stockId, int stockJournalId,
List<(int statusId, int quantity)> journalPosts, bool isNewStock = false)
{
//checks
if (journalPosts.Count > 2)
{
// I have purposely made the code to accept split transaction incase of future requirements, however, db design is simpler this way.
throw new Exception("Stock journal does not currently support split transactions (greater than two posts)." + journalPosts.Count + " number posts attempted.");
}
else if (journalPosts.Count < 2)
{
// list not long enough
throw new Exception("Stock journal entry requires minium of two posts, entry of " + journalPosts.Count + " number posts attempted.");
}
if (journalPosts.Sum(item => item.quantity) != 0)
{
// credits and debits do not match
throw new Exception("Sum of credits and debits do not resolve to zero.");
}
// group credits and debits by status
var dicStatusQty = new Dictionary<int, int>();
foreach (var post in journalPosts)
{
if (dicStatusQty.ContainsKey(post.statusId) == false)
{
dicStatusQty.Add(post.statusId, post.quantity);
}
else
{
dicStatusQty[post.statusId] = dicStatusQty[post.statusId] + post.quantity;
}
}
// get isCreditOnly for each status
var dicStatusIsCreditOnly = new Dictionary<int, bool>();
foreach (var item in dicStatusQty)
{
using (SqlCommand cmd = new SqlCommand(@"
SELECT IsCreditOnly FROM tblStockStatus WHERE StockStatusID=@statusId;
", conn))
{
cmd.Parameters.AddWithValue("@statusId", item.Key);
dicStatusIsCreditOnly.Add(item.Key, (bool)cmd.ExecuteScalar());
}
}
// check there is only one IsCreditOnly in list and it is allowed in this instance
int isCreditOnlyCount = 0;
foreach (var item in dicStatusIsCreditOnly)
{
if (item.Value)
{
isCreditOnlyCount = isCreditOnlyCount + 1;
}
}
if (isNewStock == false && isCreditOnlyCount > 0)
{
throw new Exception("Attempted credit or debit to 'Is Credit Only' status not allowed, in this instance.");
}
if (isNewStock == true && isCreditOnlyCount != 1)
{
throw new Exception("StockID=" + stockId + ", each stock line must have only have one IsCreditOnly=True status assigned to it.");
}
// ensure debit (or zero credit) isn't made to credit only status
// need to do this check via original post list (i.e. journalPosts)
foreach (var post in journalPosts)
{
// debit check
if (post.quantity >= 0)
{
if (dicStatusIsCreditOnly[post.statusId] == true)
{
throw new Exception("Cannot make debit, or zero quantity credit, to credit only status. StatusID=" + post.statusId);
}
}
}
// balance check for any credits (that are not isCreditOnly=true)
foreach (var item in dicStatusQty)
{
if (item.Value < 0 && dicStatusIsCreditOnly[item.Key] == false)
{
int quantity = new Data.Database.Stock.ReadStatusBalance().ByStockId(stockId, item.Key);
if (quantity + item.Value < 0)
{
throw new Exception("Credit status balance check failed. Available balance " + quantity + ", attempted credit " + item.Value * -1 + ".");
}
}
}
// get this far...
// insert journal posts into database
foreach (var post in journalPosts)
{
using (SqlCommand cmd = new SqlCommand(@"
INSERT INTO tblStockJournalPost ( StockJournalID, StockStatusID, Quantity )
VALUES ( @StockJournalId, @stockStatudId, @quantity );
", conn))
{
cmd.Parameters.AddWithValue("@StockJournalId", stockJournalId);
cmd.Parameters.AddWithValue("@stockStatudId", post.statusId);
cmd.Parameters.AddWithValue("@quantity", post.quantity);
// execute
cmd.ExecuteNonQuery();
}
}
}
private void StockJournalPostDelete(SqlConnection conn, int stockJournalId)
{
using (SqlCommand cmd = new SqlCommand(@"
DELETE FROM tblStockJournalPost
WHERE StockJournalID=@stockJournalId
", conn))
{
cmd.Parameters.AddWithValue("@StockJournalId", stockJournalId);
// execute
cmd.ExecuteNonQuery();
// the calling method must compete any transaction-scope on the connection
}
}
// can be used before commiting an sql insert, update or delete to the stock journal to ensure a status does not fall below 0
// (unless the status is enabled to do so)
// set empty list or statusIdEffected to null to check entier stock entries for consistency
public bool StockJournalConsistencyCheck(int stockId, List<int> statusIdEffected = null)
{
if (statusIdEffected == null)
{
statusIdEffected = new List<int>();
}
using (SqlConnection conn = new SqlConnection(SqlConnectionString))
{
conn.Open();
// if no list supplied, build list of all used status' for stockId
if (statusIdEffected.Count == 0)
{
using (SqlCommand cmd = new SqlCommand(@"
SELECT
tblStockJournalPost.StockStatusID
FROM
tblStockJournal
INNER JOIN tblStockJournalPost
ON tblStockJournal.StockJournalID = tblStockJournalPost.StockJournalID
WHERE
tblStockJournal.StockID=@stockId
GROUP BY
tblStockJournalPost.StockStatusID;
", conn))
{
cmd.Parameters.AddWithValue("@stockId", stockId);
using (var reader = cmd.ExecuteReader())
{
if (reader.HasRows)
{
while (reader.Read())
{
statusIdEffected.Add(reader.GetInt32(0));
}
}
else
{
throw new Exception("No stock journal entries exist for StockID=" + stockId);
}
}
}
}
// build the sql string to build creditCreate bool
var dicStatusCreditOnly = new Dictionary<int, bool>();
string sqlString = @"
SELECT
tblStockStatus.StockStatusID, tblStockStatus.IsCreditOnly
FROM
tblStockStatus ";
for (var i = 0; i < statusIdEffected.Count; i++)
{
if (i == 0)
{
sqlString = sqlString + " WHERE tblStockStatus.StockStatusID=" + statusIdEffected[i];
}
else
{
sqlString = sqlString + " OR tblStockStatus.StockStatusID=" + statusIdEffected[i];
}
//if (i == (statusIdEffected.Count - 1))
//{
// sqlString = sqlString + ";";
//}
}
sqlString = sqlString + " GROUP BY tblStockStatus.StockStatusID, tblStockStatus.IsCreditOnly;";
// run query & build dictionaries
using (SqlCommand cmd = new SqlCommand(sqlString, conn))
{
cmd.Parameters.AddWithValue("@stockId", stockId);
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (reader.Read())
{
dicStatusCreditOnly.Add(reader.GetInt32(0), reader.GetBoolean(1));
while (reader.Read())
{
dicStatusCreditOnly.Add(reader.GetInt32(0), reader.GetBoolean(1));
}
}
else
{
throw new Exception("Error, no journal entries found for StockID=" + stockId);
}
}
}
// check integrity of supplied statusIds
foreach (int statusId in statusIdEffected)
{
if (!dicStatusCreditOnly.ContainsKey(statusId))
{
throw new Exception("Supplied StatusId (" + statusId + ") doesn't exist for StockId=" + stockId);
}
}
// loop through each statudId and check integrity, if createdEnabled=false
foreach (int statudId in statusIdEffected)
{
if (dicStatusCreditOnly[statudId] == false)
{
using (SqlCommand cmd = new SqlCommand(@"
SELECT
tblStockJournal.EntryDate, tblStockJournalPost.Quantity
FROM
tblStockJournal
INNER JOIN tblStockJournalPost
ON tblStockJournal.StockJournalID = tblStockJournalPost.StockJournalID
WHERE
tblStockJournal.StockID=@stockId
AND tblStockJournalPost.StockStatusID=@statudId
ORDER BY
tblStockJournal.EntryDate;
", conn))
{
cmd.Parameters.AddWithValue("@stockId", stockId);
cmd.Parameters.AddWithValue("@statudId", statudId);
using (SqlDataReader reader = cmd.ExecuteReader())
{
// read first line into variables
reader.Read();
int quantity = reader.GetInt32(1);
DateTime entryDate = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc);
while (true)
{
// compare to next values
if (reader.Read())
{
DateTime nextEntryDate = DateTime.SpecifyKind(reader.GetDateTime(0), DateTimeKind.Utc);
// don't check quantites for transactions on same date
if (entryDate == nextEntryDate)
{
entryDate = nextEntryDate;
quantity = quantity + reader.GetInt32(1);
}
// check if dates are different
else
{
if (quantity < 0)
{
return false;
}
else
{
entryDate = nextEntryDate;
quantity = quantity + reader.GetInt32(1);
}
}
}
// end if no records, check quantity
else
{
if (quantity < 0)
{
return false;
}
break;
}
}
}
}
}
}
}
// get this far, all good
return true;
}
}
}

108
src/bnhtrade.Core/Data/Database/Stock/ReadSkuTransaction.cs
View File

@@ -1,10 +1,11 @@
using System;
using NUnit.Framework.Internal;
using System;
using System.Collections.Generic;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Dapper;
//using Dapper;
namespace bnhtrade.Core.Data.Database.Stock
{
@@ -76,6 +77,37 @@ namespace bnhtrade.Core.Data.Database.Stock
}
}
/// <summary>
/// Retrevies the IsProcessed for a given stock sku transaction
/// </summary>
/// <param name="skuTransactionId">the stock transaction id</param>
/// <returns></returns>
/// <exception cref="ArgumentException">Invalid stock transaction id</exception>
public bool GetIsProcessed(int skuTransactionId)
{
using (var conn = new SqlConnection(SqlConnectionString))
{
conn.Open();
using (var cmd = new SqlCommand(@"
SELECT IsProcessed FROM tblStockSkuTransaction WHERE StockSkuTransactionID=@skuTransactionId
", conn))
{
cmd.Parameters.AddWithValue("@skuTransactionId", skuTransactionId);
object obj = cmd.ExecuteScalar();
if (obj == null || obj == DBNull.Value)
{
throw new ArgumentException("invalid stock transaction id");
}
else
{
return (bool)obj;
}
}
}
}
/// <summary>
/// Populates model class from filtered database results
@@ -88,7 +120,8 @@ namespace bnhtrade.Core.Data.Database.Stock
// Adding this means they at least get processed in the correct order (maybe)!
var resultList = new List<Model.Stock.SkuTransaction>();
var parameters = new DynamicParameters();
//var parameters = new DynamicParameters();
var parameterNew = new Dictionary<string, object>();
string sql = @"
SELECT tblStockSkuTransaction.StockSkuTransactionID AS SkuTransactionId
@@ -102,7 +135,7 @@ namespace bnhtrade.Core.Data.Database.Stock
,tblStockSkuTransactionType.TypeCode AS SkuTransactionTypeCode
,tblStockSkuTransactionType.TypeName AS SkuTransactionTypeName
,tblSku.skuSkuNumber AS SkuNumber
,tblStockSkuTransaction.SkuID
,tblStockSkuTransaction.RecordCreated
FROM tblStockSkuTransaction
INNER JOIN tblStockSkuTransactionType ON tblStockSkuTransaction.StockSkuTransactionTypeID = tblStockSkuTransactionType.StockSkuTransactionTypeID
INNER JOIN tblSku ON tblStockSkuTransaction.SkuID = tblSku.skuSkuID
@@ -110,7 +143,7 @@ namespace bnhtrade.Core.Data.Database.Stock
if (transactionIdList.Any())
{
parameters.Add("@transactionIdList", this.transactionIdList);
parameterNew.Add("@transactionIdList", this.transactionIdList);
sql += @"
AND tblStockSkuTransaction.StockSkuTransactionID IN @transactionIdList ";
@@ -133,7 +166,7 @@ namespace bnhtrade.Core.Data.Database.Stock
if (StockTransactionTypeName != null && StockTransactionTypeName.Any())
{
parameters.Add("@stockTransactionTypeName", StockTransactionTypeName);
parameterNew.Add("@stockTransactionTypeName", StockTransactionTypeName);
sql += @"
AND tblStockSkuTransactionType.TypeName IN @stockTransactionTypeName ";
@@ -141,7 +174,7 @@ namespace bnhtrade.Core.Data.Database.Stock
if (StockTransactionTypeCode != null && StockTransactionTypeCode.Any())
{
parameters.Add("@stockTransactionTypeCode", StockTransactionTypeCode);
parameterNew.Add("@stockTransactionTypeCode", StockTransactionTypeCode);
sql += @"
AND tblStockSkuTransactionType.TypeCode IN @stockTransactionTypeCode ";
@@ -155,23 +188,64 @@ namespace bnhtrade.Core.Data.Database.Stock
{
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)
using (SqlCommand cmd = new SqlCommand(sql, conn))
{
resultList[i].TransactionDate = DateTime.SpecifyKind(resultList[i].TransactionDate, DateTimeKind.Utc);
foreach (var param in parameterNew)
{
cmd.Parameters.AddWithValue(param.Key, param.Value);
}
using (SqlDataReader reader = cmd.ExecuteReader())
{
if (!reader.HasRows)
{
return resultList;
}
else
{
while (reader.Read())
{
int skuTransactionId = reader.GetInt32(0);
DateTime transactionDate = DateTime.SpecifyKind(reader.GetDateTime(1), DateTimeKind.Utc);
int? foreignKey = null;
if (!reader.IsDBNull(2)) { reader.GetInt32(2); }
string reference = null;
if (!reader.IsDBNull(3)) { reader.GetString(3); }
string detail = null;
if (!reader.IsDBNull(4)) { reader.GetString(4); }
int quantity = reader.GetInt32(5);
bool isProcessed = reader.GetBoolean(6);
int? stockJournalId = null;
if (!reader.IsDBNull(7)) { reader.GetInt32(7); }
string skuTransactionTypeCode = reader.GetString(8);
string skuTransactionTypeName = reader.GetString(9);
string skuNumber = reader.GetString(10);
DateTime recordCreated = DateTime.SpecifyKind(reader.GetDateTime(11), DateTimeKind.Utc);
var item = new Model.Stock.SkuTransaction(skuTransactionId, transactionDate, skuTransactionTypeCode, foreignKey, reference
, detail, skuNumber, quantity, isProcessed, stockJournalId, recordCreated);
resultList.Add(item);
}
}
}
}
}
return resultList;
}
/// <summary>
/// Get Stock SKU Transaction by ID
/// Get Stock SKU Transaction by ID. Overrides any filters already set.
/// </summary>
/// <param name="transactionIdList"></param>
/// <returns>List of SkuTransaction</returns>

10
src/bnhtrade.Core/Data/Database/Stock/ReadSkuTransactionType.cs
View File

@@ -23,7 +23,7 @@ namespace bnhtrade.Core.Data.Database.Stock
public int GetTypeId(string typeCode)
{
/* GetStockTransactionTypeId return meanings
* >0 use the as the TypeId when inserting transaction
* >0 use 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 */
@@ -123,15 +123,17 @@ namespace bnhtrade.Core.Data.Database.Stock
}
}
public List<Model.Stock.SkuTransactionType> ByTypeCode(List<string> typeCode)
public List<Model.Stock.SkuTransactionType> ByTypeCode(List<string> typeCodeList)
{
typeCode.RemoveAll(string.IsNullOrWhiteSpace);
typeCodeList.RemoveAll(string.IsNullOrWhiteSpace);
typeCodeList = typeCodeList.Distinct().ToList();
string sqlWhere = @"
WHERE TypeCode IN @typeCode ";
var param = new DynamicParameters();
param.Add("@typeCode", typeCode);
param.Add("@typeCode", typeCodeList);
return Execute(sqlWhere, param);
}

266
src/bnhtrade.Core/Data/Database/Stock/UpdateSkuTransaction.cs
View File

@@ -4,150 +4,28 @@ using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Transactions;
namespace bnhtrade.Core.Data.Database.Stock
{
public class UpdateSkuTransaction : Connection
{
// Any update method below to the quanity, isprocessed or journalId, implements a consistancy check.
private string err = "Database UpdateSkuTransaction: ";
private ReadSkuTransaction dbRead = new ReadSkuTransaction();
public UpdateSkuTransaction()
{
}
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)
{
// Consistancy check: is the target marked as is processed?
dbRead.Init();
if (dbRead.GetIsProcessed(skuTransaction.SkuTransactionId))
throw new InvalidOperationException("Update restricted, sku transaction isProcessed=true");
using (var conn = new SqlConnection(SqlConnectionString))
{
conn.Open();
@@ -176,16 +54,16 @@ namespace bnhtrade.Core.Data.Database.Stock
{
cmd.Parameters.AddWithValue("@transactionDate", skuTransaction.TransactionDate.ToUniversalTime());
cmd.Parameters.AddWithValue("@skuTransactionTypeCode", skuTransaction.SkuTransactionTypeCode);
if (!skuTransaction.IsSetForeignKey) { cmd.Parameters.AddWithValue("@foreignKey", DBNull.Value); }
if (skuTransaction.ForeignKey == null) { cmd.Parameters.AddWithValue("@foreignKey", DBNull.Value); }
else { cmd.Parameters.AddWithValue("@foreignKey", skuTransaction.ForeignKey); }
if (!skuTransaction.IsSetReference) { cmd.Parameters.AddWithValue("@reference", DBNull.Value); }
if (skuTransaction.Reference == null) { cmd.Parameters.AddWithValue("@reference", DBNull.Value); }
else { cmd.Parameters.AddWithValue("@reference", skuTransaction.Reference); }
if (!skuTransaction.IsSetDetail) { cmd.Parameters.AddWithValue("@detail", DBNull.Value); }
if (skuTransaction.Detail == null) { 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); }
if (skuTransaction.StockJournalId == null) { cmd.Parameters.AddWithValue("@stockJournalID", DBNull.Value); }
else { cmd.Parameters.AddWithValue("@stockJournalID", skuTransaction.StockJournalId); }
cmd.Parameters.AddWithValue("@transactionId", skuTransaction.SkuTransactionId);
@@ -198,5 +76,123 @@ namespace bnhtrade.Core.Data.Database.Stock
}
}
}
/// <summary>
/// Update the isProcessed and StockJournalId field, with journal consistancy check.
/// </summary>
/// <param name="skuTransactionId">Sku Transaction Id</param>
/// <param name="isProcessed"></param>
/// <param name="stockJournalId"></param>
/// <exception cref="InvalidOperationException">Invalid journalId, isProcessed combination</exception>
/// <exception cref="Exception">DB update sql fail</exception>
public void UpdateIsProcessed(int skuTransactionId, bool isProcessed, int? stockJournalId, bool enableJournalDelete = false)
{
// IMPORTANT!!!!
// For consistancy reasons: need to make sure that if a journal entry exists, it is deteled before it is
// edited, or removed from the transaction table
// Best to implement this here, at only point where the isprocessed/journalId can be updated
// intial checks
if (isProcessed == false && stockJournalId != null)
throw new InvalidOperationException("If stock journal id is set, isProcessed must be true");
using (var scope = new TransactionScope())
{
try
{
// check for existing journal Id in transactin table
var existingJournalId = new Data.Database.Stock.ReadSkuTransaction().GetJournalId(skuTransactionId);
bool journalDeleteRequired = false;
if (existingJournalId != null)
{
if (stockJournalId == null || stockJournalId != existingJournalId)
{
journalDeleteRequired = true;
}
}
// make the journal delete, if required and enabled
if (journalDeleteRequired && enableJournalDelete)
{
new Data.Database.Stock.JournalCrud().StockJournalDelete((int)existingJournalId);
}
else
{
throw new InvalidOperationException("Removal of stock journal to update sku transaction table not allowed");
}
// update the transaction table
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))
{
cmd.Parameters.AddWithValue("@isProcessed", isProcessed);
if (stockJournalId == null) { cmd.Parameters.AddWithValue("@stockJournalID", DBNull.Value); }
else { cmd.Parameters.AddWithValue("@stockJournalID", (int)stockJournalId); }
cmd.Parameters.AddWithValue("@transactionId", skuTransactionId);
int effected = cmd.ExecuteNonQuery();
if (effected != 1)
{
throw new Exception(err += "Sku Transaction StockJournalID update failed");
}
}
}
scope.Complete();
}
catch (Exception ex)
{
scope.Dispose();
throw ex;
}
}
}
/// <summary>
/// Update the quantity field, with journal consistancy check.
/// </summary>
/// <param name="skuTransactionId">stock sku transaction id</param>
/// <param name="quantity">quantity</param>
/// <exception cref="InvalidOperationException">Update restricted, sku transaction isProcessed=true</exception>
/// <exception cref="Exception">Database write failed</exception>
public void UpdateQuanitity(int skuTransactionId, int quantity)
{
// Consistancy check: is the target marked as is processed?
dbRead.Init();
if (dbRead.GetIsProcessed(skuTransactionId))
throw new InvalidOperationException("Update restricted, sku transaction isProcessed=true");
using (var conn = new SqlConnection(SqlConnectionString))
{
conn.Open();
using (SqlCommand cmd = new SqlCommand(@"
UPDATE tblStockSkuTransaction
SET Quantity = @quantity
WHERE StockSkuTransactionID = @transactionId
", conn))
{
cmd.Parameters.AddWithValue("@quantity", quantity);
int effected = cmd.ExecuteNonQuery();
if (effected != 1)
{
throw new Exception(err += "stockSkuTransaction Quantity update failed");
}
}
}
}
}
}