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 static IEnumerable <string> GetTopics(
this TransactionLogEntity entity)
{
yield return(entity.Topic0);
if (entity.Topic1 != null)
{
yield return(entity.Topic1);
}
else
{
yield break;
}
if (entity.Topic2 != null)
{
yield return(entity.Topic2);
}
else
{
yield break;
}
if (entity.Topic3 != null)
{
yield return(entity.Topic3);
}
}
public async Task AddAsync(TransactionLogEntity entity)
{
var repository = _efUnitOfWork.CommandRepository <TransactionLogEntity>();
await repository.AddAsync(entity);
await _efUnitOfWork.SaveChangesAsync(default);
//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 TransactionLogBinder(TransactionLogEntity transactionLog, TransactionPartyEntity transactionParty)
{
TransactionDate = transactionLog.TransactionDateTime;
Remarks = transactionLog.Remarks;
Amount = (transactionLog.IsIncome ? transactionLog.Amount : -1.0 * transactionLog.Amount).ToString("0.00");
Balance = (transactionLog.FinalBalance).ToString("0.00");
TransactionPartyCode = transactionParty.Code;
}
public async Task LogErrorAsync(string invalidTransactionsJson)
{
var logEntity = new TransactionLogEntity()
{
CreatedAt = DateTime.UtcNow,
LogType = LogType.Error,
InvalidTransactionsJson = invalidTransactionsJson
};
await _transactionLogRepository.AddAsync(logEntity);
}
protected override void OnLykkeModelCreating(
ModelBuilder modelBuilder)
{
ABIEntity.OnLykkeModelCreating(modelBuilder);
EventEntity.OnLykkeModelCreating(modelBuilder);
EventParameterEntity.OnLykkeModelCreating(modelBuilder);
FunctionCallEntity.OnLykkeModelCreating(modelBuilder);
FunctionCallParameterEntity.OnLykkeModelCreating(modelBuilder);
TransactionEntity.OnLykkeModelCreating(modelBuilder);
TransactionLogEntity.OnLykkeModelCreating(modelBuilder);
}
public TransactionLogBinder(TransactionLogEntity transactionLog, TransactionPartyEntity transactionParty)
{
TransactionDate = transactionLog.TransactionDateTime.ToString("dd-MM-yyyy h:mm tt");
Remarks = transactionLog.Remarks;
Amount = (transactionLog.IsIncome ? transactionLog.Amount : -1.0 * transactionLog.Amount).ToString("0.00");
Balance = (transactionLog.FinalBalance).ToString("0.00");
TransactionParty = transactionParty.Code;
isDeleted = transactionLog.IsDeletedTransaction == true ? "Yes" : "No";
Type = transactionLog.ScheduledTransactionId == null ? "One Time" : "Scheduled";
CreatedDate = transactionLog.CreatedDateTime.ToString("dd-MM-yyyy h:mm tt");
PerformedBy = transactionLog.IsUserPerformed ? "User" : "System";
}
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 static TransactionLog ToDto(this TransactionLogEntity src)
{
if (src == null)
{
throw new ArgumentNullException(nameof(src));
}
return(new TransactionLog
{
Address = src.Address,
LogIndex = src.LogIndex,
TransactionHash = src.TransactionHash,
Topics = src.GetTopics().ToArray(),
BlockTimestamp = src.BlockTimestamp
});
}
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 async Task SaveDecodedAsync(IEnumerable <Tuple <long, string> > transactionLogs)
{
using (var context = _contextFactory.CreateDataContext())
{
foreach (var txLog in transactionLogs)
{
var e = new TransactionLogEntity
{
LogIndex = txLog.Item1, TransactionHash = txLog.Item2
};
context.TransactionLogs.Attach(e);
e.Decoded = true;
}
await context.SaveChangesAsync();
}
}
public void Insert(TransactionLogEntity request)
{
var parameter = new[]
{
new SqlParameter("@AccountId", request.AccountId),
new SqlParameter("@TransactionType", request.TransactionType),
new SqlParameter("@TransactionDate", request.TransactionDate),
new SqlParameter("@Amount", request.Amount),
new SqlParameter("@DestinationAccountId", request.DestinationAccountId),
};
using (var conn = new SqlConnection(SQLHelper.GetConnectionString()))
{
SQLHelper.ExecuteNonQuery(
conn,
CommandType.Text,
@"INSERT INTO dbo.TransactionLog
(AccountId, TransactionType, TransactionDate, Amount, DestinationAccountId)
SELECT @AccountId, @TransactionType, @TransactionDate, @Amount, @DestinationAccountId",
parameter);
}
}
public async Task <int> InsertTransactionLogAsync(TransactionLogEntity transactionLogEntity)
{
string query = "INSERT INTO `TransactionLog`" +
"(`TransactionId`,`ScheduledTransactionId`,`TransactionPartyId`,`IsDeletedTransaction`,`IsIncome`,`TransactionDateTime`,`Amount`,`StartingBalance`,`FinalBalance`,`Remarks`,`CreatedDateTime`,`IsUserPerformed`) " +
"VALUES(@TransactionId,@ScheduledTransactionId,@TransactionPartyId,@IsDeletedTransaction,@IsIncome,@TransactionDateTime,@Amount,@StartingBalance,@FinalBalance,@Remarks,@CreatedDateTime,@IsUserPerformed);";
IEnumerable <KeyValuePair <string, object> > parameters = new List <KeyValuePair <string, object> >()
{
new KeyValuePair <string, object>("@TransactionId", transactionLogEntity.TransactionId),
new KeyValuePair <string, object>("@ScheduledTransactionId", transactionLogEntity.ScheduledTransactionId),
new KeyValuePair <string, object>("@TransactionPartyId", transactionLogEntity.TransactionPartyId),
new KeyValuePair <string, object>("@IsDeletedTransaction", transactionLogEntity.IsDeletedTransaction ? 1 : 0),
new KeyValuePair <string, object>("@IsIncome", transactionLogEntity.IsIncome ? 1 : 0),
new KeyValuePair <string, object>("@Amount", transactionLogEntity.Amount),
new KeyValuePair <string, object>("@StartingBalance", transactionLogEntity.StartingBalance),
new KeyValuePair <string, object>("@FinalBalance", transactionLogEntity.FinalBalance),
new KeyValuePair <string, object>("@Remarks", transactionLogEntity.Remarks),
new KeyValuePair <string, object>("@TransactionDateTime", TimeConverterMethods.ConvertDateTimeToTimeStamp(transactionLogEntity.TransactionDateTime)),
new KeyValuePair <string, object>("@CreatedDateTime", TimeConverterMethods.ConvertDateTimeToTimeStamp(transactionLogEntity.CreatedDateTime)),
new KeyValuePair <string, object>("@IsUserPerformed", transactionLogEntity.IsUserPerformed ? 1 : 0)
};
return(await SqliteConnector.ExecuteInsertQueryAsync(query, parameters, true));
}
