public async Task <IActionResult> WalletNotified(string txid)
{
try
{
var existentTransaction = transactionService.FindInDatabase(txid);
var transaction = await transactionService.GetTransaction(txid);
if (existentTransaction == null)
{
transactionService.Add(transaction);
}
else
{
transactionService.UpdateConfirmations(transaction.TxId, transaction.Confirmations);
}
if (walletService.GetWallet() == null)
{
await walletService.CreateWalletIfNecessary();
}
else
{
await walletService.UpdateWalletBalance();
}
await unitOfWork.SaveChanges();
existentTransaction = transactionService.FindInDatabase(txid);
return(Ok(existentTransaction.TxId));
}
catch (RpcErrorException ex)
{
return(BadRequest(ex.Error));
}
}
public IActionResult Add(string payerName, int points, DateTime timestamp)
{
_service.Add(new TransactionRecord {
PayerName = payerName, Points = points, Timestamp = timestamp
});
return(Ok());
}
private void SaveTransaction()
{
try
{
var deposit = Convert.ToDecimal(txtQuantity.Text);
var withdrawal = Convert.ToDecimal(txtWithDrawal.Text);
var cardIdentifier = Convert.ToString(GetObjectFromCombobox(cmbCards));
var account = accountService.GetAccountForCardIdentifier(cardIdentifier);
var transaction = new Transaction
{
AccountId = account.Id,
TransactionDate = DateTime.Now,
AssignedCard = cardIdentifier,
Deposit = deposit,
Withdrawal = withdrawal
};
transactionService.Add(transaction);
}
catch (Exception ee)
{
throw;
}
}
public ActionResult Add(TransactionsAddRequest request)
{
var userId = UserId;
if (request.ContragentId == userId)
{
return(BadRequest(new { message = "Контрагент является текущим пользователем" }));
}
try {
_transactionService.Add(userId, request.ContragentId, request.Amount);
} catch (UserNotFoundException e) {
switch (e.Name)
{
case "Payee": return(Unauthorized());
case "Recepient": return(BadRequest(new { message = "Контрагент не найден" }));
}
} catch (ArgumentException e) {
switch (e.ParamName)
{
case "amount":
return(BadRequest(new { message = "Недостаточно средств" }));
}
throw;
}
_unitOfWork.Complete();
return(Ok());
}
public IActionResult CreateMoneyTransaction(TransactionDto transaction)
{
var result = _transaction.Add(transaction);
if (!result.IsError)
{
return(Ok(result));
}
return(BadRequest(result));
}
public IActionResult Post(TransactionDataTransferObject transaction)
{
var transactionResult = _transactionService.Add(transaction);
if (transactionResult.ResponseCode != ResponseCode.Success)
{
return(BadRequest(transactionResult.Error));
}
return(Ok(transactionResult.Result));
}
public void WhenAddIsCalled()
{
subject = new TransactionService(transactions);
subject.Add(new TransactionRecord {
PayerName = "Test", Points = 100, Timestamp = DateTime.Now
});
var response = subject.GetPayerBalance();
response.Should().HaveCount(4, because: "a transaction with a new payer was added to the list");
}
public async Task <List <PaymentNotification> > Confirm(string reference, string hiDee)
{
var paymentNotification = await _context.PaymentNotifications.Where(x => x.Reference == reference).FirstOrDefaultAsync();
if (paymentNotification == null)
{
throw new AppException("Payment notification is not found");
}
var user = await _context.Users.Where(x => x.Email == paymentNotification.Email).FirstOrDefaultAsync();
if (user == null || ((user != null) && (!hiDee.Equals(GlobalVariables.BaseKey()))))
{
throw new AppException("User is not found");
}
if (paymentNotification.Confirmed == "Yes")
{
paymentNotification.Confirmed = "No";
paymentNotification.UpdateAllowed = true;
await _transactionService.Delete(paymentNotification.Reference);
if (paymentNotification.TransactionType == "Activation")
{
user.ActivationRequested = true;
user.ActivationFeePaid = false;
}
}
else
{
paymentNotification.Confirmed = "Yes";
paymentNotification.UpdateAllowed = false;
var transaction = new Transaction {
Reference = paymentNotification.Reference,
TransactionType = paymentNotification.TransactionType,
Email = paymentNotification.Email,
AmountPaid = paymentNotification.AmountPaid,
PaymentChannel = paymentNotification.PaymentChannel
};
await _transactionService.Add(transaction);
if (paymentNotification.TransactionType == "Activation")
{
user.ActivationRequested = true;
user.ActivationFeePaid = true;
}
}
_context.PaymentNotifications.Update(paymentNotification);
_context.Users.Update(user);
await _context.SaveChangesAsync();
return(await _context.PaymentNotifications.OrderByDescending(x => x.DateAdded).ToListAsync());
}
public IActionResult Post([FromBody] TransactionModel model)
{
if (model == null)
{
return(BadRequest());
}
transactionService.Add(model);
return(Ok());
}
public Task Handle(TransactionCreatedEvent @event)
{
_transactionService.Add(new TransactionInvoice()
{
Id_Transaccion = @event.Id_Transaction,
Id_Invoice = @event.Id_Invoice,
Amount = @event.Amount,
Date = @event.Date
});
return(Task.CompletedTask);
}
public IActionResult Add(Transaction transaction)
{
var AccountId = transactionService.AllAccounts().Where(a => a.Name == transaction.ToAccountName);
foreach (var acc in AccountId)
{
transaction.ToAccountId = acc.Id;
}
transaction.FromAccountId = transaction.AccountId;
transactionService.Add(transaction);
return(RedirectToAction("add"));
}
public HttpResponseMessage Create(HttpRequestMessage request, TransactionViewModel transactionVM)
{
return(CreateHttpResponse(request, () =>
{
if (!ModelState.IsValid)
{
return request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
else
{
var transaction = new Transaction();
//var transactionDetails = transactionVM.TransactionDetails;
ICollection <TransactionDetail> transactionDetails = transactionVM.TransactionDetails;
var responseData = Mapper.Map <IEnumerable <TransactionDetail>, IEnumerable <TransactionDetailViewModel> >(transactionDetails);
//transactionVM.TransactionDetails = new List<TransactionDetail>();
if (transactionVM.UserId == null)
{
transactionVM.UserId = _userService.getByUserName(User.Identity.Name).Id;
}
transactionVM.CreatedBy = User.Identity.Name;
transaction.UpdateTransaction(transactionVM);
_transactionService.Add(transaction);
_transactionService.Save();
foreach (var item in responseData)
{
item.TransactionID = transaction.ID;
item.CreatedBy = User.Identity.Name;
item.CreatedDate = DateTime.Now;
var dbTransactionDetail = new TransactionDetail();
dbTransactionDetail.UpdateTransactionDetail(item);
_transactionDetailService.Add(dbTransactionDetail);
_transactionDetailService.Save();
}
//foreach (var item in transactionDetails)
//{
// item.TransactionId = transactionVM.ID;
// transactionVM.TransactionDetails.Add(item);
//}
//foreach (var item in responseData)
//{
// var dbTransactionDetail = new TransactionDetail();
// dbTransactionDetail.UpdateTransactionDetail(item);
// dbTransactionDetail.TransactionId = item.ID;
// //_transactionDetailService.Add(dbTransactionDetail);
//}
return request.CreateErrorResponse(HttpStatusCode.OK, transaction.ID.ToString());
}
}));
}
public ActionResult Create(TransactionEditModel model)
{
if (!ModelState.IsValid)
{
return(View("Create", model));
}
model.Transaction.Updated = DateTime.Now;
model.Transaction.ByUser = User.Identity.Name;
_transactionService.Add(model.Transaction);
return(RedirectToAction("Index"));
}
public Task Handle(TransactionCreatedEvent @event)
{
_service.Add(new Model.Transaction()
{
TransactionId = @event.TransactionId,
InvoiceId = @event.InvoiceId,
Amount = @event.Amount,
Date = @event.Date
});
return(Task.CompletedTask);
}
public static void Initialize(IUnitOfWork unitOfWork, IUserService userService, ITransactionService transactionService)
{
if (unitOfWork.Users.Any())
{
return;
}
void UserAdd(string name, string domain = "example.com", string password = "******", double balance = 500)
{
var login = $"{name.Replace(" ", "")}@{domain}";
userService.Register(name, login, password, password, balance);
}
UserAdd("Kyle Porter");
UserAdd("Tommy Stevens");
UserAdd("Jordan Hart");
UserAdd("Walter White", "bb.com", "C10h15N", 1000000);
UserAdd("Samuel Knight");
UserAdd("Tyler Dean");
UserAdd("Jordan Briggs");
UserAdd("Maddox Hewitt");
UserAdd("Shawn Lindsey");
UserAdd("Jaden Cote");
UserAdd("Jett Benjamin");
unitOfWork.Complete();
var users = unitOfWork.Users.GetAll().ToDictionary(x => x.Name, x => x.Id);
void TransactionAdd(string dtString, string payeeName, string recepientName, double amount)
{
var dt = DateTime.Parse(dtString);
var payee = users[payeeName];
var recepient = users[recepientName];
transactionService.Add(dt, payee, recepient, amount);
}
TransactionAdd("2019.03.05 12:00:00", "Kyle Porter", "Tommy Stevens", 200);
TransactionAdd("2019.03.05 12:30:00", "Kyle Porter", "Jordan Hart", 200);
TransactionAdd("2019.03.08 09:30:00", "Walter White", "Kyle Porter", 1000);
TransactionAdd("2019.03.09 12:00:00", "Kyle Porter", "Tyler Dean", 200);
TransactionAdd("2019.03.09 12:30:00", "Kyle Porter", "Jordan Briggs", 200);
TransactionAdd("2019.03.10 17:45:00", "Shawn Lindsey", "Walter White", 500);
TransactionAdd("2019.03.10 17:45:01", "Jaden Cote", "Walter White", 500);
TransactionAdd("2019.03.10 17:45:02", "Jett Benjamin", "Walter White", 500);
TransactionAdd("2019.03.12 11:00:00", "Maddox Hewitt", "Tyler Dean", 50);
unitOfWork.Complete();
}
public IActionResult Post([FromBody] Transaction value)
{
if (value == null)
{
return(ResponseModel.Instance.ReturnResult(HttpStatusCode.NotAcceptable, "value cannot be null"));
}
if (!ModelState.IsValid)
{
return(ResponseModel.Instance.ReturnResult(HttpStatusCode.BadRequest, "model is not valid."));
}
_service.Add(value);
return(ResponseModel.Instance.ReturnResult(HttpStatusCode.OK));
}
public JsonResult Create(Transaction trans)
{
var userId = User.Identity.GetUserId();
if (!string.IsNullOrEmpty(userId))
{
var user = userService.Get(userId);
trans.UserId = userId;
trans.CompanyId = user.CompanyId;
var result = transactionService.Add(trans);
return(Json(result));
}
return(Json(true));
}
public void No_EndTransaction_EventsRaisedTest()
{
var clientId = 101;
_undoStackManager.CreateStackForClient(clientId);
var undoStack = _undoStackManager.GetStackOfClient(clientId);
int eventsRaised = 0;
undoStack.ActiveStateChanged += (sender, changeSet) =>
{
eventsRaised++;
};
_transactionService.StartTransaction(clientId);
_transactionService.Add(
new Change(ChangeReason.InsertAt, 1, new TestObject())
, clientId);
Assert.AreEqual(0, eventsRaised);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var result = await _transactionService.Add(Transaction);
if (result.HasError)
{
Errors = string.Join(" /n ", result.ErrorMessages);
return(Page());
}
return(RedirectToPage("./Success"));
}
public async Task <ActionResult> Post(
[FromQuery] Guid transactionId,
[FromQuery] Guid playerId,
[FromQuery] TransactionType transactionType,
[FromQuery] decimal amount)
{
var balance = await _playerService.GetBalance(playerId);
if (!balance.HasValue)
{
return(StatusCode(StatusCodes.Status400BadRequest, "Rejected."));
}
return(await _transactionService.Add(transactionId, playerId, transactionType, amount, balance.Value)
? Ok("Accepted")
: StatusCode(StatusCodes.Status400BadRequest, "Rejected."));
}
public ActionResult AddTransactions(TransactionCreateViewModel model)
{
try
{
transactionService.Add(model);
}catch (Exception ex)
{
Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
return(Json(new JsonMessage()
{
Status = JsonResultStatus.Fail, Message = "Adding failure"
}, JsonRequestBehavior.AllowGet));
}
return(Json(new JsonMessage()
{
Status = JsonResultStatus.Success, Message = "Adding successfully"
}, JsonRequestBehavior.AllowGet));
}
public ActionResult Create(TransactionModel model)
{
try
{
Transaction transaction = model;
_transactionService.Add(transaction);
return(RedirectToAction(nameof(Index), new TransactionsViewModel
{
transactions = _transactionService.GetListByCategoryId(transaction.CategoryId),
categories = _categoryService.GetAll(),
category = _categoryService.GetByCategoryId(transaction.CategoryId)
}));
}
catch
{
return(View());
}
}
/// <inheritdoc />
public Account AddAccount(int customerId, double initialCredit)
{
var response = IsValidCustomer(customerId);
if (response.Equals(Response.Success))
{
var account = accountService.Add(customerId);
if (!initialCredit.NearlyEqual(0))
{
transactionService.Add(account.Id, initialCredit);
}
return(accountService.GetById(account.Id));
}
else
{
throw new MyBankException(response);
}
}
public ActionResult Confirm(int id, string note, bool status)
{
var res = false;
Transaction transaction = new Transaction();
transaction.OrderID = id;
transaction.Note = note;
transaction.Status = status;
var idUser = userService.FindByUsername(User.Identity.Name).ID;
transaction.CreateBy = idUser;
res = transactionService.Add(transaction);
// chuyển trạng thái order
var order = orderService.FindById(id);
order.Status = false;
orderService.Update(order);
transactionService.Save();
return(Json(res, JsonRequestBehavior.AllowGet));
}
public ActionResult <TransactionDto> Post(int accountId, [FromBody] TransactionDto transactionDto)
{
var transaction = new Transaction
{
Amount = transactionDto.Amount,
TransactionDate = transactionDto.Date,
Description = transactionDto.Description,
AccountId = accountId
};
var serviceResult = _transactionService.Add(transaction);
if (serviceResult.ResponseCode != ResponseCode.Success)
{
return(BadRequest(serviceResult.Error));
}
transactionDto.Id = serviceResult.Result.Id;
return(Ok(transactionDto));
}
public IActionResult Add([FromBody] Transaction transaction)
{
Console.WriteLine(transaction.FromAccountName);
Console.WriteLine(transaction.ToAccountName);
transaction.Id = Guid.NewGuid();
var AccountId = transactionService.AllAccounts().Where(a => a.Name == transaction.ToAccountName);
foreach (var acc in AccountId)
{
transaction.ToAccountId = acc.Id;
}
var fromAccountId = transactionService.AllAccounts().Where(a => a.Name == transaction.FromAccountName);
foreach (var frAcc in fromAccountId)
{
transaction.FromAccountId = frAcc.Id;
transaction.AccountId = frAcc.Id;
}
transactionService.Add(transaction);
return(Ok(transaction));
}
public BaseResponse <TransferResponse> Transfer(string userId, TransferRequest transferRequest)
{
var response = new BaseResponse <TransferResponse>();
try
{
transferRequest.UserId = userId;
TransferValidator transferValidator = new TransferValidator(_checkingAccountService);
FluentValidation.Results.ValidationResult validationResult = transferValidator.Validate(transferRequest);
if (!validationResult.IsValid)
{
response.AddErrors(validationResult.Errors);
return(response);
}
var from = _checkingAccountService.UpdateBalance(transferRequest.NumberFrom, transferRequest.Amount * -1);
var to = _checkingAccountService.UpdateBalance(transferRequest.NumberTo, transferRequest.Amount);
_transactionService.Add(new Transaction
{
Amount = transferRequest.Amount,
FromCheckingAccountId = from.Id,
ToCheckingAccountId = to.Id
});
_checkingAccountService.Commit();
response.Data = new TransferResponse {
Balance = from.Balance
};
}
catch (Exception ex)
{
_checkingAccountService.Rollback();
response.AddError(1, "Erro inesperado");
}
return(response);
}
public void Run()
{
while (IsContinue)
{
var transaction =
_loggerService.RunWithExceptionLogging(
() => _transactionGenerator.GenerateTransaction(_transactionValidators),
isSilent: true
);
if (transaction == null)
{
return;
}
_transactionService.Add(transaction);
_loggerService.Info(
$"\n{transaction.Seller.FirstName} {transaction.Seller.SurName} -> {transaction.Buyer.FirstName} {transaction.Buyer.SurName},\nstock number = {transaction.StocksQuantity}, stock price = {transaction.Stock.Price}\n");
Thread.Sleep(2000);
}
_repositoryClient.SaveChanges();
}
public static void AddTransactionService(this IBus bus, ITransactionService transactionService)
{
bus.Respond <TransactionAddMqRequest, TransactionAddMqResponse>(transactionAddMessageRequest =>
{
TransactionAddMqResponse transactionAddMessageResponse = transactionService.Add(transactionAddMessageRequest);
return(transactionAddMessageResponse);
});
bus.Respond <TransactionGetByIdMqRequest, TransactionGetMqResponse>(transactionGetByIdMessageRequest =>
{
TransactionGetMqResponse transactionGetMessageResponse = transactionService.GetById(transactionGetByIdMessageRequest);
return(transactionGetMessageResponse);
});
bus.Respond <TransactionGetAllByClientMqRequest, TransactionGetAllMqResponse>(transactionGetByClientMessageRequest =>
{
TransactionGetAllMqResponse transactionGetMessageResponse = transactionService.GetAllByClient(transactionGetByClientMessageRequest);
return(transactionGetMessageResponse);
});
}
public void AddUpdate(IUndoable oldState, IUndoable newState, string description, int clientId)
{
var updateChange = new Change(oldState.Id, oldState, newState);
_transactionService.Add(updateChange, clientId, description);
}