public bool SaveTransaction(int userId, long amount, bool isIncome)
{
bool isSavedTransaction = false;
try
{
TransactionLogs transaction = new TransactionLogs()
{
UserId = userId,
Amount = amount,
IsIncome = isIncome
};
var user = _db.transactionLogs.Add(transaction);
_db.SaveChanges();
isSavedTransaction = true;
return(isSavedTransaction);
}
catch (Exception ex)
{
Console.WriteLine(ex.ToString());
return(false);
}
}
public async Task <UserEntity> InsertUserEntityAsync(UserEntity userEntity)
{
int id = await _userModel.InsertUserDetailsAsync(userEntity);
CurrentUser = await _userModel.GetUserDetailsAsync();
TransactionLogEntity transactionLogEntity = new TransactionLogEntity()
{
TransactionId = 0,
TransactionPartyId = 1, // OWN
ScheduledTransactionId = null,
IsDeletedTransaction = false,
IsIncome = true,
TransactionDateTime = DateTime.Now,
Amount = userEntity.StartingAmount,
StartingBalance = 0,
FinalBalance = userEntity.StartingAmount,
CreatedDateTime = DateTime.Now,
IsUserPerformed = true,
Remarks = "Starting Balance"
};
int tranLogId = await _transactionLogModel.InsertTransactionLogAsync(transactionLogEntity);
transactionLogEntity = await _transactionLogModel.GetTransactionLogByIdAsync(tranLogId);
IList <TransactionLogEntity> transactionLogs = TransactionLogs.ToList();
transactionLogs.Add(transactionLogEntity);
TransactionLogs = transactionLogs;
return(CurrentUser);
}
public ActionResult TransactionLogAddEdit(int?id)
{
BackEndTransactionLogAddEdit transactionLogAddEdit = new BackEndTransactionLogAddEdit();
if (id.IsNotNull())
{
TransactionLogs transactionLogs = new TransactionLogs();
var transactionLog = transactionLogs.FilterById(id);
if (transactionLog.IsNotNull())
{
transactionLogAddEdit.Id = transactionLog.Id;
transactionLogAddEdit.Id_Fighting = transactionLog.Id_Fighting;
transactionLogAddEdit.TransationDate = transactionLog.TransationDate.ToDateTimeString();
transactionLogAddEdit.ReceiveAccount = transactionLog.ReceiveAccount;
transactionLogAddEdit.TransationType = transactionLog.TransationType;
transactionLogAddEdit.Amount = transactionLog.Amount;
transactionLogAddEdit.UserId = transactionLog.UserId;
transactionLogAddEdit.Nick = transactionLog.Nick;
transactionLogAddEdit.Reason = transactionLog.Reason;
transactionLogAddEdit.Status = transactionLog.Status;
transactionLogAddEdit.ErrorMessage = transactionLog.ErrorMessage;
transactionLogAddEdit.Created_At = transactionLog.Created_At.ToDateTimeString();
transactionLogAddEdit.Updated_At = transactionLog.Updated_At.ToDateTimeString();
}
}
return(View(transactionLogAddEdit));
}
public ActionResult TransactionLogDelete(int?deleteId)
{
string username = BackEndSessions.CurrentUser.UserName;
TransactionLogs transactionLogs = new TransactionLogs();
switch (transactionLogs.Delete(deleteId, username))
{
case 0:
ModelState.AddResult(ViewData, ModelStateResult.Success, Resources.Strings.ItemSuccessfullyDeleted);
break;
case 2:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.ItemDoesNotExist);
break;
case 3:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.ItemUsedSomewhereElse);
break;
default:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.UnexpectedError);
break;
}
return(RedirectToAction("TransactionLogs"));
}
//ApplicationErrorLog applicationErrorLog = new ApplicationErrorLog();
public async Task <TransactionEntity> InsertTransactionAsync(TransactionEntity transaction, bool isUserPerformed = false)
{
await _insertTransactionSemaphoreSlim.WaitAsync();
try
{
int tId = await _transactionModel.InsertTransactionAsync(transaction, isUserPerformed);
transaction = await _transactionModel.GetTransactionByIdAsync(tId);
IList <TransactionEntity> transactions = Transactions.ToList();
transactions.Add(transaction);
double startingBalance = CurrentUser.CurrentBalance;
double newBalance = startingBalance + ((transaction.IsIncome ? 1 : -1) * transaction.Amount);
await _userModel.UpdateUserCurrentBalanceAsync(newBalance);
UserEntity userEntity = await _userModel.GetUserDetailsAsync();
TransactionLogEntity transactionLog = new TransactionLogEntity()
{
Amount = transaction.Amount,
IsIncome = transaction.IsIncome,
IsDeletedTransaction = false,
ScheduledTransactionId = transaction.ScheduledTransactionId,
TransactionDateTime = transaction.TransactionDateTime,
CreatedDateTime = DateTime.Now,
IsUserPerformed = isUserPerformed,
TransactionId = transaction.Id,
TransactionPartyId = transaction.TransactionPartyId,
Remarks = $"Transaction: {transaction.ReferenceNumber} Added",
StartingBalance = startingBalance,
FinalBalance = newBalance,
};
int tlId = await _transactionLogModel.InsertTransactionLogAsync(transactionLog);
transactionLog = await _transactionLogModel.GetTransactionLogByIdAsync(tlId);
IList <TransactionLogEntity> transactionLogs = TransactionLogs.ToList();
transactionLogs.Add(transactionLog);
Transactions = transactions;
TransactionLogs = transactionLogs;
CurrentUser = userEntity;
return(transaction);
}
catch (Exception k)
{
applicationErrorLog.ErrorLog("Transaction", "Insert onetime transaction", k.ToString());
return(transaction);
}
finally
{
_insertTransactionSemaphoreSlim.Release();
}
}
public async Task <TransactionEntity> UpdateTransactionAsync(TransactionEntity transaction)
{
TransactionEntity beforeTransaction = await _transactionModel.GetTransactionByIdAsync(transaction.Id);
await _transactionModel.UpdateTransactionAsync(transaction);
TransactionEntity afterTransaction = await _transactionModel.GetTransactionByIdAsync(transaction.Id);
//get diffrent amount
double differenceIncome = (afterTransaction.IsIncome ? 1 : -1) * afterTransaction.Amount - (beforeTransaction.IsIncome ? 1 : -1) * beforeTransaction.Amount;
double startingBalance = CurrentUser.CurrentBalance;
double newBalance = startingBalance + differenceIncome;
await _userModel.UpdateUserCurrentBalanceAsync(newBalance);
UserEntity userEntity = await _userModel.GetUserDetailsAsync();
TransactionLogEntity transactionLog = new TransactionLogEntity()
{
Amount = Math.Abs(differenceIncome),
IsIncome = differenceIncome > 0,
IsDeletedTransaction = false,
ScheduledTransactionId = transaction.ScheduledTransactionId,
TransactionDateTime = transaction.TransactionDateTime,
CreatedDateTime = DateTime.Now,
IsUserPerformed = true,
TransactionId = transaction.Id,
TransactionPartyId = transaction.TransactionPartyId,
Remarks = $"Transaction: {beforeTransaction.ReferenceNumber} Updated; Diff: {differenceIncome}",
StartingBalance = startingBalance,
FinalBalance = newBalance,
};
int tlId = await _transactionLogModel.InsertTransactionLogAsync(transactionLog);
transactionLog = await _transactionLogModel.GetTransactionLogByIdAsync(tlId);
IList <TransactionLogEntity> transactionLogs = TransactionLogs.ToList();
transactionLogs.Add(transactionLog);
IEnumerable <TransactionEntity> transactions = await _transactionModel.GetTransactionsAsync();
Transactions = transactions;
TransactionLogs = transactionLogs;
CurrentUser = userEntity;
return(afterTransaction);
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
TransactionLogs = await _context.TransactionLogs.FirstOrDefaultAsync(m => m.Id == id);
if (TransactionLogs == null)
{
return(NotFound());
}
return(Page());
}
public ActionResult TransactionLogs(BackEndTransactionLogList backEndTransactionLogList)
{
TransactionLogs transactionLogs = new TransactionLogs();
backEndTransactionLogList.TransactionLogs = transactionLogs.GetAll(
backEndTransactionLogList.TransationDate,
backEndTransactionLogList.UserId,
backEndTransactionLogList.Nick,
backEndTransactionLogList.Reason
);
if (backEndTransactionLogList.TransactionLogs.IsNull() || backEndTransactionLogList.TransactionLogs.Count == 0)
{
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.NoDataFound);
}
return(View(backEndTransactionLogList));
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
TransactionLogs = await _context.TransactionLogs.FindAsync(id);
if (TransactionLogs != null)
{
_context.TransactionLogs.Remove(TransactionLogs);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}
public async Task DeleteTransactionAsync(int id)
{
await _transactionModel.DeleteTransactionAsync(id);
TransactionEntity transaction = await _transactionModel.GetTransactionByIdAsync(id);
double startingBalance = CurrentUser.CurrentBalance;
double newBalance = startingBalance + (transaction.IsIncome ? -1 : 1) * transaction.Amount; // Reversed because transaction deleted
await _userModel.UpdateUserCurrentBalanceAsync(newBalance);
UserEntity userEntity = await _userModel.GetUserDetailsAsync();
TransactionLogEntity transactionLog = new TransactionLogEntity()
{
Amount = transaction.Amount,
IsIncome = !transaction.IsIncome,
IsDeletedTransaction = true,
ScheduledTransactionId = transaction.ScheduledTransactionId,
TransactionDateTime = DateTime.Now,
CreatedDateTime = DateTime.Now,
IsUserPerformed = true,
TransactionId = transaction.Id,
TransactionPartyId = transaction.TransactionPartyId,
Remarks = $"Transaction: {transaction.ReferenceNumber} Deleted",
StartingBalance = startingBalance,
FinalBalance = newBalance,
};
int tlId = await _transactionLogModel.InsertTransactionLogAsync(transactionLog);
transactionLog = await _transactionLogModel.GetTransactionLogByIdAsync(tlId);
IList <TransactionLogEntity> transactionLogs = TransactionLogs.ToList();
transactionLogs.Add(transactionLog);
IList <TransactionEntity> transactions = Transactions.ToList();
TransactionEntity deletedTransaction = transactions.First(tp => tp.Id == id);
deletedTransaction.IsActive = false;
Transactions = transactions;
TransactionLogs = transactionLogs;
CurrentUser = userEntity;
}
public ActionResult TransactionLogAddEdit(BackEndTransactionLogAddEdit transactionLogAddEdit)
{
string username = BackEndSessions.CurrentUser.UserName;
TransactionLogs categories = new TransactionLogs();
long? currentId = transactionLogAddEdit.Id;
if (ModelState.IsValidOrRefresh())
{
var rs = categories.AddEdit(
currentId,
transactionLogAddEdit.Id_Fighting,
transactionLogAddEdit.TransationDate.ToDateTime(),
transactionLogAddEdit.ReceiveAccount,
transactionLogAddEdit.TransationType,
transactionLogAddEdit.Amount,
transactionLogAddEdit.UserId,
transactionLogAddEdit.Nick,
transactionLogAddEdit.Reason,
transactionLogAddEdit.Status,
transactionLogAddEdit.ErrorMessage,
transactionLogAddEdit.Created_At.ToDateTime(),
transactionLogAddEdit.Updated_At.ToDateTime(),
username
);
switch (rs)
{
case 0:
ModelState.AddResult(ViewData, ModelStateResult.Success, Resources.Strings.ItemSuccessfullyAddEdit);
break;
case 2:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.ItemDoesNotExist);
break;
default:
ModelState.AddResult(ViewData, ModelStateResult.Error, Resources.Strings.UnexpectedError);
break;
}
}
return(View(transactionLogAddEdit));
}
public static TransactionLogs ExtractAMSData(FTPSClient client, string directory, TransactionLogs tl)
{
TransactionLogs amstl = new TransactionLogs();
amstl.TimeRecorded = tl.TimeRecorded;
amstl.SaleNo = tl.SaleNo;
amstl.Filename = tl.Filename;
try
{
// Download file
string tempFile = directory + "temp";
client.GetFile(tl.Filename, tempFile);
// Extract sale number and description
XmlTextReader reader = new XmlTextReader(tempFile);
amstl = ExtractAMSXMLData(tempFile, tl);
// Delete temp file
File.Delete(tempFile);
}
catch (FTPCommandException fce)
{
LogMsg("FTP Command problem " + fce.InnerException + " Error Code " + fce.ErrorCode + " File " + tl.Filename);
// MessageBox.Show("FTP Command problem " + fce.InnerException);
}
catch (FTPException fe)
{
LogMsg("FTP problem " + fe.InnerException);
// MessageBox.Show("FTP problem " + fe.InnerException);
}
catch (IOException ie)
{
LogMsg("IO problem " + ie.InnerException);
}
return(amstl);
}
public static TransactionLogs ExtractAMSXMLData(string tempFile, TransactionLogs tl)
{
TransactionLogs amstl = new TransactionLogs();
amstl.TimeRecorded = tl.TimeRecorded;
amstl.SaleNo = tl.SaleNo;
amstl.Filename = tl.Filename;
// Extract sale number and description
XmlTextReader reader = new XmlTextReader(tempFile);
try
{
string field1 = "";
string field2 = "";
string field3 = "";
string field4 = "";
bool Done = false;
while ((reader.Read()) && (Done == false))
{
switch (reader.NodeType)
{
case XmlNodeType.Element: // The node is an element.
if (reader.Name.IndexOf("transcript") > -1)
{
field1 = "";
field2 = "";
field3 = "";
field4 = "";
}
if (reader.Name.IndexOf("sale") > -1)
{
amstl.AMSSaleCode = reader["id"];
amstl.SaleNo = reader["id"];
}
if (reader.IsEmptyElement)
{
// Do nothing
}
else if (field1.Length == 0)
{
field1 = reader.Name;
}
else if (field2.Length == 0)
{
field2 = reader.Name;
}
else if (field3.Length == 0)
{
field3 = reader.Name;
}
else
{
field4 = reader.Name;
}
break;
case XmlNodeType.Text: //Display the text in each element.
if (field2.IndexOf("date") > -1)
{
field2 = "";
}
if (field3.IndexOf("date") > -1)
{
amstl.AMSSaleDate = Convert.ToDateTime(reader.Value).ToString("dd/MM/yyyy HH:mm");
amstl.AMSSaleDate = Convert.ToDateTime(reader.Value).ToString("MM/dd/yyyy HH:mm");
field3 = "";
}
if (field3.Length > 0)
{
if (field3.IndexOf("description") > -1)
{
amstl.AMSDescription = reader.Value;
field3 = "";
}
if (field3.IndexOf("code") > -1)
{
amstl.AMSSaleCode = reader.Value;
amstl.SaleNo = reader["id"];
field3 = "";
}
if (field3.IndexOf("site") > -1)
{
amstl.AMSSite = reader.Value;
field3 = "";
}
}
break;
case XmlNodeType.EndElement: //Display the end of the element.
if (reader.Name.IndexOf("sale") > -1)
{
Done = true;
}
break;
default:
break;
}
}
}
catch (IOException ie)
{
LogMsg(ie);
}
catch (XmlException xe)
{
// MessageBox.Show(xe.Message);
LogMsg(xe);
}
reader.Close();
return(amstl);
}
