public async Task <IActionResult> AddOrEdit(int id, Transaction transactionModel)
{
if (ModelState.IsValid)
{
//Insert
if (id == 0)
{
transactionModel.Date = DateTime.Now;
_context.Add(transactionModel);
await _context.SaveChangesAsync();
}
//Update
else
{
try
{
_context.Update(transactionModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactionModelExists(transactionModel.TransactionId))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Json(new { isValid = true, html = Helper.RenderRazorViewToString(this, "_ViewAll", _context.Transactions.ToList()) }));
}
return(Json(new { isValid = false, html = Helper.RenderRazorViewToString(this, "AddOrEdit", transactionModel) }));
}
public async Task <IActionResult> AddOrEdit(int id, [Bind("TransactionId,AccountNumber,BeneficiaryName,BankName,SWIFTCode,Amount,Date")] Transaction transaction)
{
if (ModelState.IsValid)
{
if (id == 0)
{
transaction.Date = DateTime.Now;
_context.Add(transaction);
await _context.SaveChangesAsync();
}
else
{
try
{
_context.Update(transaction);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactionExists(transaction.TransactionId))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Json(new { isValid = true, html = Helper.RenderRazorViewToString(this, "_ViewAll", _context.Transactions.ToList()) }));
}
return(Json(new { isValid = false, html = Helper.RenderRazorViewToString(this, "AddOrEdit", transaction) }));
}
public async Task <IActionResult> Create([Bind("TransactionID,AccountController,BeneficaryName,BankName,Code,Amount")] TransactionModel transactionModel)
{
if (ModelState.IsValid)
{
_context.Add(transactionModel);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(transactionModel));
}
public async Task <IActionResult> UploadFile(List <IFormFile> files)
{
TransactionModel transactionModel = new TransactionModel();
foreach (var formFile in files)
{
var lines = System.IO.File.ReadAllLines(System.IO.Path.Combine(_env.WebRootPath, @"..\OFX\" + formFile.FileName));
foreach (var line in lines)
{
if (line.Equals("<STMTTRN>"))
{
transactionModel = new TransactionModel();
}
else if (line.Contains("<TRNTYPE>"))
{
transactionModel.Type = line.Replace("<TRNTYPE>", "");
}
else if (line.Contains("<DTPOSTED>"))
{
string date = line.Replace("<DTPOSTED>", "");
date = date.Substring(0, 8);
date = DateTime.ParseExact(date, "yyyyMMdd", System.Globalization.CultureInfo.InvariantCulture).ToString("dd/MM/yyyy", System.Globalization.CultureInfo.InvariantCulture);
transactionModel.Date = DateTime.Parse(date);
}
else if (line.Contains("<TRNAMT>"))
{
transactionModel.Amount = double.Parse((double.Parse(line.Replace("<TRNAMT>", "")) / 100).ToString("f2"));
}
else if (line.Contains("<MEMO>"))
{
transactionModel.Memo = line.Replace("<MEMO>", "");
}
else if (line.Equals("</STMTTRN>"))
{
var alreadyExists = await _context.Transactions.AnyAsync(x => x.Type == transactionModel.Type &&
x.Date == transactionModel.Date && x.Amount == transactionModel.Amount &&
x.Memo == transactionModel.Memo);
if (alreadyExists == false)
{
_context.Add(transactionModel);
await _context.SaveChangesAsync();
}
}
}
}
return(RedirectToAction(nameof(Index)));
}
public async Task ProcessTransactionsAsync(IAsyncEnumerable <Transaction> transactions)
{
try
{
await foreach (var trItem in transactions)
{
var trEntity = await _dbContext.Transaction.FindAsync(trItem.TransactionId);
if (trEntity != null)
{
trEntity.Amount = trItem.Amount;
trEntity.Currency = trItem.Currency;
trEntity.Status = trItem.Status;
trEntity.TransactionDate = trItem.TransactionDate;
_dbContext.Transaction.Update(trEntity);
}
else
{
await _dbContext.Transaction.AddAsync(trItem);
}
}
await _dbContext.SaveChangesAsync();
}
catch (Exception ex)
{
_logger.LogError(ex, "Error processing transactions");
throw;
}
}
public async Task Create(AccountTransactionEntity accountTransactionEntity, AccountSummaryEntity accountSummaryEntity)
{
_accountTransactionEntity.Add(accountTransactionEntity);
_accountSummaryEntity.Add(accountSummaryEntity);
bool isSaved = false;
while (!isSaved)
{
try
{
await _dbContext.SaveChangesAsync();
isSaved = true;
}
catch (DbUpdateConcurrencyException ex)
{
foreach (var entry in ex.Entries)
{
if (entry.Entity is AccountSummaryEntity)
{
var databaseValues = entry.GetDatabaseValues();
if (databaseValues != null)
{
entry.OriginalValues.SetValues(databaseValues);
CalculateNewBalance();
void CalculateNewBalance()
{
var balance = (decimal)entry.OriginalValues["Balance"];
var amount = accountTransactionEntity.Amount;
if (accountTransactionEntity.TransactionType == TransactionType.Deposit.ToString())
{
accountSummaryEntity.Balance = balance += amount;
}
else if (accountTransactionEntity.TransactionType == TransactionType.Withdrawal.ToString())
{
if (amount > balance)
{
throw new InsufficientBalanceException();
}
accountSummaryEntity.Balance = balance -= amount;
}
}
}
else
{
throw new NotSupportedException();
}
}
}
}
}
}
// add or update transaction
public async Task <ServiceResponse <Transaction> > AddOrUpdateTransaction(AddOrUpdateTransactionVm addOrUpdateTransaction)
{
ServiceResponse <Transaction> serviceResponse = new ServiceResponse <Transaction>();
var transaction = await _context.Transactions.FirstOrDefaultAsync(t => t.Id == addOrUpdateTransaction.Id);
try
{
if (transaction == null)
{
Transaction newTransaction = new Transaction
{
Status = addOrUpdateTransaction.Status,
Type = addOrUpdateTransaction.Type,
ClientName = addOrUpdateTransaction.ClientName,
Amount = addOrUpdateTransaction.Amount
};
await _context.Transactions.AddAsync(newTransaction);
await _context.SaveChangesAsync();
serviceResponse.Data = newTransaction;
serviceResponse.Message = "You're transactions has been added";
}
else
{
transaction.Status = addOrUpdateTransaction.Status;
transaction.Type = addOrUpdateTransaction.Type;
transaction.ClientName = addOrUpdateTransaction.ClientName;
transaction.Amount = addOrUpdateTransaction.Amount;
_context.Transactions.Update(transaction);
await _context.SaveChangesAsync();
serviceResponse.Data = transaction;
serviceResponse.Message = "You're transaction has been updated";
}
}
catch (Exception ex)
{
serviceResponse.Success = false;
serviceResponse.Message = ex.Message;
}
return(serviceResponse);
}
public async Task AddErrorLogAsync(string fileName, string message, Stream stream)
{
var fileDb = new File
{
FileName = fileName
};
_transactionDbContext.Files.Add(fileDb);
await _transactionDbContext.SaveChangesAsync();
_transactionDbContext.Logs.Add(new LogDb
{
Message = message,
Level = LogLevel.Error,
FileId = fileDb.Id
});
await _transactionDbContext.SaveChangesAsync();
await StreamFileContentToServerAsync(stream, fileDb.Id);
}
public async Task <bool> Handle(UploadFileCommand request, CancellationToken cancellationToken)
{
var parser = _factory.Create(request.File.FileName);
var transactions = parser.ParseAll(request.File);
await _context.Transactions.AddRangeAsync(transactions, cancellationToken);
await _context.SaveChangesAsync(cancellationToken);
return(true);
}
public async Task <IActionResult> AddOrEdit(int id, [Bind("EmpleadoId,TipoDocumentoId,NumeroDocumento,Nombres,Apellidos,AreaId,FechaNacimiento")] EmpleadoModel empleadoModel)
{
if (ModelState.IsValid)
{
//Insert
if (id == 0)
{
empleadoModel.FechaCreacion = DateTime.Now;
_context.Add(empleadoModel);
await _context.SaveChangesAsync();
}
//Update
else
{
try
{
//empleadoModel.FechaNacimiento = Convert.ToDate(empleadoModel.FechaNacimiento.ToString("dd/MM/yyyy"));
empleadoModel.FechaCreacion = DateTime.Now;
_context.Update(empleadoModel);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TransactionModelExists(empleadoModel.EmpleadoId))
{
return(NotFound());
}
else
{
throw;
}
}
}
return(Json(new { isValid = true, html = Helper.RenderRazorViewToString(this, "_ViewAll", _context.Empleado.ToList()) }));
}
return(Json(new { isValid = false, html = Helper.RenderRazorViewToString(this, "AddOrEdit", empleadoModel) }));
}
public async Task <IActionResult> CreateTransaction([FromBody] TransactionItem transaction)
{
var item = new TransactionItem {
TransactionTypeId = transaction.TransactionTypeId,
Ammount = transaction.Ammount,
NameOrig = transaction.NameOrig,
NameDest = transaction.NameDest,
TransactionDate = DateTime.Now
};
_transactionContext.TransactionItems.Add(item);
await _transactionContext.SaveChangesAsync();
return(CreatedAtAction(nameof(GetTransactionById), new { id = item.Id }, null));
}
/// <summary>
/// Seed database
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
private static void Seed(TransactionDbContext context)
{
if (!context.Addresses.Any())
{
Address wAddress = new Address();
wAddress.Line1 = "111 Work Place Circle";
wAddress.City = "Tucson";
wAddress.State = State.AZ;
wAddress.ZipCode = "85747";
context.Addresses.Add(wAddress);
Address hAddress = new Address();
hAddress.Line1 = "222 Home Lane";
hAddress.City = "Dallas";
hAddress.State = State.TX;
hAddress.ZipCode = "75261";
context.Addresses.Add(hAddress);
}
if (!context.People.Any())
{
for (int i = 0; i < 5; i++)
{
Person p = new Person();
p.EmailAddress = String.Format("p{0}@gmail.com", i);
p.FirstName = String.Format("First{0}", i);
p.LastName = String.Format("First{0}", i);
p.PhoneNumber = String.Format("({0}{0}{0}) {0}{0}{0}-{0}{0}{0}{0}", i);
p.HomeAddress = context.Addresses.FirstOrDefault();
context.People.Add(p);
}
}
if (!context.Transactions.Any())
{
Random r = new Random();
for (int i = 10; i < 10; i++)
{
Transaction t = new Transaction();
t.Amount = r.NextDouble();
t.Payee = context.People.Where(x => x.Id == 1).FirstOrDefault();
t.Payer = context.People.Where(x => x.Id == 2).FirstOrDefault();
}
}
context.SaveChangesAsync();
}
public async Task AddLedgerData(SellerData sell, BuyerData buy, decimal Quantities)
{
Ledger ledger = new Ledger();
ledger.BuyerId = buy.BuyId.ToString();
ledger.DisplayId = Guid.NewGuid().ToString();
ledger.BuyerPrice = (double)buy.BuyPrice;
ledger.SellerId = sell.SellerId.ToString();
ledger.SellerPrice = (double)sell.SellPrice;
ledger.SellerQuantity = (long)Quantities;
ledger.ProcessTime = DateTime.Now;
ledger.TransactionStatus = TransactionStatus.Success;
_transactionDbContext.Ledgers.Add(ledger);
await _transactionDbContext.SaveChangesAsync();
}
/// <summary>
/// Save query into database
/// </summary>
/// <param name="transactions"></param>
/// <returns></returns>
public async Task <SaveTransactionResponse> SaveTransactionsAsync(IEnumerable <TransactionData> transactions)
{
var response = new SaveTransactionResponse();
await _transactionDbContext.Transactions.AddRangeAsync(transactions);
try
{
await _transactionDbContext.SaveChangesAsync();
}
catch (Exception e)
{
response.Errors.AddRange(new[] { e.Message, e.InnerException?.Message });
return(response);
}
return(response);
}
static async Task Main(string[] args)
{
const string endpointName = "Bank.Transaction";
Console.Title = endpointName;
var endpointConfiguration = new EndpointConfiguration(endpointName);
endpointConfiguration.EnableInstallers();
//if in development
endpointConfiguration.PurgeOnStartup(true);
var appSettings = ConfigurationManager.AppSettings;
string transactionConnection = ConfigurationManager.ConnectionStrings["TransactionConnectionString"].ToString();
var transportConnection = ConfigurationManager.ConnectionStrings["TransportConnection"].ToString();
var auditQueue = appSettings.Get("AuditQueue");
var userEndpoint = appSettings.Get("UserEndpoint");
var schemaName = appSettings.Get("SchemaName");
var tablePrefix = appSettings.Get("TablePrefix");
var serviceControlQueue = appSettings.Get("ServiceControlQueue");
var timeToBeReceivedSetting = appSettings.Get("TimeToBeReceived");
var timeToBeReceived = TimeSpan.Parse(timeToBeReceivedSetting);
var containerSettings = endpointConfiguration.UseContainer(new DefaultServiceProviderFactory());
containerSettings.ServiceCollection.AddScoped(typeof(ITransactionRepository), typeof(TransactionRepository));
//containerSettings.ServiceCollection.AddAutoMapper(typeof(Program));
containerSettings.ServiceCollection.AddAutoMapper(typeof(DataMappingProfile));
using (var transactionDataContext = new TransactionDbContext(new DbContextOptionsBuilder <TransactionDbContext>()
.UseSqlServer(new SqlConnection(transactionConnection))
.Options))
{
await transactionDataContext.Database.EnsureCreatedAsync();
}
var persistence = endpointConfiguration.UsePersistence <SqlPersistence>();
persistence.SqlDialect <SqlDialect.MsSqlServer>();
persistence.ConnectionBuilder(
connectionBuilder: () =>
{
return(new SqlConnection(transactionConnection));
});
var dialect = persistence.SqlDialect <SqlDialect.MsSqlServer>();
dialect.Schema(schemaName);
var outboxSettings = endpointConfiguration.EnableOutbox();
outboxSettings.KeepDeduplicationDataFor(TimeSpan.FromDays(6));
outboxSettings.RunDeduplicationDataCleanupEvery(TimeSpan.FromMinutes(15));
var transport = endpointConfiguration.UseTransport <RabbitMQTransport>();
transport.UseConventionalRoutingTopology()
.ConnectionString(transportConnection);
var routing = transport.Routing();
routing.RouteToEndpoint(
messageType: typeof(ICommitTransaction),
destination: userEndpoint);
var recoverability = endpointConfiguration.Recoverability();
recoverability.Delayed(
customizations: delayed =>
{
delayed.NumberOfRetries(0);
delayed.TimeIncrease(TimeSpan.FromMinutes(3));
});
recoverability.Immediate(
customizations: delayed =>
{
delayed.NumberOfRetries(1);
});
var conventions = endpointConfiguration.Conventions();
conventions.DefiningCommandsAs(type => type.Namespace == "Messages.Commands");
conventions.DefiningEventsAs(type => type.Namespace == "Messages.Events");
conventions.DefiningMessagesAs(type => type.Namespace == "Messages.Messages");
var subscriptions = persistence.SubscriptionSettings();
subscriptions.CacheFor(TimeSpan.FromMinutes(10));
endpointConfiguration.AuditProcessedMessagesTo(
auditQueue: auditQueue,
timeToBeReceived: timeToBeReceived);
endpointConfiguration.AuditSagaStateChanges(
serviceControlQueue: "Particular.Servicecontrol");
endpointConfiguration.RegisterComponents(c =>
{
c.ConfigureComponent(b =>
{
var session = b.Build <ISqlStorageSession>();
var context = new TransactionDbContext(new DbContextOptionsBuilder <TransactionDbContext>()
.UseSqlServer(session.Connection)
.Options);
//Use the same underlying ADO.NET transaction
context.Database.UseTransaction(session.Transaction);
//Ensure context is flushed before the transaction is committed
session.OnSaveChanges(s => context.SaveChangesAsync());
return(context);
}, DependencyLifecycle.InstancePerUnitOfWork);
});
var endpointInstance = await Endpoint.Start(endpointConfiguration);
Console.WriteLine("Press Enter to exit.");
Console.ReadLine();
await endpointInstance.Stop();
}
public async Task AddBuyerData(BuyerData buyerData)
{
_transactionDbContext.BuyerDatas.Add(buyerData);
await _transactionDbContext.SaveChangesAsync();
}
public async Task <IActionResult> PostPayment([FromBody] Transaction transaction)
{
// Determine merchant from username
var merchantUsername = _MerchantUsernameContext.MerchantUsername.Where(s => s.Username == User.Identity.Name.ToString()).FirstOrDefault();
if (merchantUsername == null)
{
return(Unauthorized());
}
else
{
// Forward payment to bank
var BankTransaction = new BankTransaction
{
PayeeBankAccount = transaction.MerchantBankAccount,
PayerCardNumber = transaction.CardNumber,
ExpMonth = transaction.ExpMonth,
ExpYear = transaction.ExpYear,
CVV = transaction.CVV,
Amount = transaction.Amount,
Currency = transaction.Currency
};
Bank bank = new Bank();
HttpResponseMessage response = await bank.SendPayment(BankTransaction);
// Retrieve bank transaction id
var content = await response.Content.ReadAsStringAsync();
var jsonContent = JObject.Parse(content);
string BankTransactionId;
try
{
BankTransactionId = jsonContent["transactionId"].ToString();
}
catch (NullReferenceException e)
{
BankTransactionId = "";
}
// Saves transaction in database
var NewTransaction = new Transaction()
{
Merchant = merchantUsername.Merchant.ToString(),
MerchantBankAccount = transaction.MerchantBankAccount,
CardNumber = transaction.CardNumber,
ExpMonth = transaction.ExpMonth,
ExpYear = transaction.ExpYear,
CVV = transaction.CVV,
Amount = transaction.Amount,
Currency = transaction.Currency,
TransactionType = "Payment",
BankTransactionId = BankTransactionId,
BankResponseStatus = response.StatusCode.ToString(),
DateTime = DateTime.UtcNow,
Status = (response.StatusCode == HttpStatusCode.OK ? TransactionStatus.Processed : TransactionStatus.Failed)
};
_TransactionContext.Transaction.Add(NewTransaction);
await _TransactionContext.SaveChangesAsync();
// Retrieve the transaction ID
string CurrentTransactionId = _TransactionContext.Transaction.Where(s => s.Merchant == NewTransaction.Merchant &&
s.CardNumber == NewTransaction.CardNumber &&
s.Amount == NewTransaction.Amount &&
s.TransactionType == NewTransaction.TransactionType &&
s.Status == NewTransaction.Status &&
s.DateTime == NewTransaction.DateTime
).FirstOrDefault().Id.ToString();
if (response.StatusCode == HttpStatusCode.OK)
{
return(Ok("Payment Processed. " + "Transaction ID: " + CurrentTransactionId));
}
else
{
return(BadRequest("Payment Failed. " + "Transaction ID: " + CurrentTransactionId));
}
}
}
public async Task CreateAsync(IEnumerable <Transaction> entity)
{
await _context.Transactions.AddRangeAsync(entity);
await _context.SaveChangesAsync();
}
public async Task CompleteAsync()
{
await _dbContext.SaveChangesAsync();
}
public async Task AddSellerData(SellerData sellerData)
{
_transactionDbContext.SellerDatas.Add(sellerData);
await _transactionDbContext.SaveChangesAsync();
}
public void SaveChangesAsync()
{
_dbContext.SaveChangesAsync();
}
