public async Task <IActionResult> BurnCoupon(string offerNumber)
{
var lang = Request.Path.Value.Split('/')[2]?.ToString() == "ar-SA" ? "ar" : "en";
var mobileNumber = User.Claims.FirstOrDefault(c => c.Type == "mobileNumber").Value;
var burnResponse = await _couponsService.BurnCouponsAsync(mobileNumber, offerNumber, lang == "ar"? "2" : "1");
if (burnResponse.ErrorCode != "0")
{
_logger.Information($"Coupons Burn Response Message: {burnResponse.ErrorMessage}, ErrorCode: {burnResponse.ErrorCode}");
burnResponse.ErrorMessage = _localizer["CouponsError"];
if (burnResponse.ErrorCode == "4")
{
burnResponse.ErrorMessage = _localizer["CouponBurnedBefore"];
}
if (burnResponse.ErrorCode == "2")
{
burnResponse.ErrorMessage = _localizer["WorngCouponNumber"];
}
return(BadRequest(burnResponse.ErrorMessage));
}
_ = _ecouponsService.EBurn(new ECouponBurnRequest {
Mobile = mobileNumber, Barcode = offerNumber
})
.ContinueWith(res =>
{
if (res.Exception != null)
{
_logger.Error(res.Exception, $"Ecoupons Error: {res.Exception.Message}");
}
else
{
_logger.Information($"Ecoupons Burn Response Message: {res.Result.Result.ResponseHeader.Message}");
}
});
var user = await _userRepository.UpdatePoints(mobileNumber, 1);
var isAdded = await _transactionRepository.AddTransaction(user, TransactionType.Burn, user.Points - 1, offerNumber, "", "");
if (!isAdded)
{
_logger.Information($"Add Transaction Failed For Mobile: {user.MobileNumber}, Type: Burn, OfferNumber: {offerNumber}");
}
var token = _authRepository.GenerateToken(user);
var res = await _couponsService.GetTierOffers(user.Points, lang);
var offers = res.Deals;
return(Ok(new { token, burnResponse, offers }));
}
public async Task AddBalance(int userId, decimal amount)
{
var balance = await _userRepository.GetBalance(userId) ?? 0;
balance = balance + amount;
using (var transaction = new BgsTransactionScope())
{
await _userRepository.UpdateBalance(userId, balance);
await _transactionRepository.AddTransaction((int)TransactionType.Deposit, userId, (int)TransactionStatus.Success, DateTime.Now, amount);
transaction.Complete();
};
}
public ActionResult CouponRegister(FormViewModel model)
{
if (ModelState.IsValid)
{
Transaction transaction = new Transaction
{
TransactionID = model.GetTransactionViewModel.TransactionID,
CustomerID = model.GetTransactionViewModel.CustomerID,
PrizeID = model.GetTransactionViewModel.PrizeID,
CouponNumber = model.GetTransactionViewModel.CouponNumber,
TransactionNumber = model.GetTransactionViewModel.TransactionNumber,
TransactionValue = model.GetTransactionViewModel.TransactionValue,
TransactionDate = model.GetTransactionViewModel.TransactionDate
};
couponRepository.RedeemCoupon(transaction);
transactionRepository.AddTransaction(transaction);
TempData["message"] = string.Format("{0} is saved", model.GetTransactionViewModel.TransactionNumber);
return(RedirectToAction("TransactionList"));
}
else
{
return(View("CouponRegister", model));
}
}
/// <summary>
/// Adds a transaction to the repository.
/// </summary>
/// <param name="amount">The amount of the transaction.</param>
/// <param name="description">The description of the transaction.</param>
/// <param name="category">The category that the transaction falls into.</param>
public void AddTransaction(double amount, string description, Category category)
{
mLatestId++;
var transaction = new Transaction(mLatestId, amount, category, description);
mTransactionRepository.AddTransaction(transaction);
}
public async Task <IActionResult> AddTransactioin([FromBody] TransactionViewModel transactionViewModel)
{
User user = await userManager.GetUserAsync(HttpContext.User);
var transaction = new Transaction
{
Amount = transactionViewModel.Amount,
Coment = transactionViewModel.Coment,
Categorie = categorieRepository.GetCategoryByID(transactionViewModel.Category.ID),
User = user,
Date = transactionViewModel.Date,
IsExpense = transactionViewModel.IsExpense
};
var tmp = transactionRepository.AddTransaction(transaction).Result;
return(Json(new TransactionViewModel
{
Amount = tmp.Amount,
Category = new CategoryViewModel
{
ID = tmp.Categorie.ID,
Name = tmp.Categorie.Name,
},
Date = tmp.Date,
IsExpense = tmp.IsExpense,
ID = tmp.ID,
Coment = tmp.Coment
}));
}
public async Task AddTransaction(TransactionForAdditionDto transaction)
{
var transactionModelForRepo = mapper.Map <TransactionForAdditionForRepo>(transaction);
transactionModelForRepo.Price = await getTransactionPriceOperation.Run(transaction);
await repo.AddTransaction(transactionModelForRepo);
}
public ActionResult Add(TransactionViewModel viewModel, String isPost)
{
var data = _autoMapper.Map <TransactionViewModel, TransactionData>(viewModel);
_transactionRepository.AddTransaction(data);
_transactionFileWrapper.WriteCurrentHoldings(_transactionRepository.GetCurrentHoldings());
var viewResult = new ViewResult
{
ViewName = "Add"
};
viewResult.ViewBag.Message =
$"{EnumParser.GetDescription(viewModel.TransactionType)} transaction for {viewModel.Code} completed";
return(viewResult);
}
public async Task <Transaction> AddTransaction(NewTransaction transaction, long userId)
{
var type = await transactionTypeApp.Get(transaction.TransactionTypeId);
transaction.Amount = type.Type == "I" ? transaction.Amount : transaction.Amount * -1;
transaction.UserId = userId;
return(await repository.AddTransaction(transaction));
}
public IActionResult AddTransaction([FromBody] Transactions trans)
{
int res = _tranRepo.AddTransaction(trans);
if (res != 0)
{
return(Ok(res));
}
return(Forbid());
}
public void AddTransaction(string input)
{
var transaction = _transactionParser.Parse(input);
_transactionRepository.AddTransaction(transaction);
var commission = _commissionCalculator.Calc(transaction);
if (commission != null)
{
_transactionRepository.AddTransaction(commission);
}
//if (transaction is Transfer)
//{
// var commission = new Commission(transaction);
// _transactionRepository.AddTransaction(commission);
//}
}
public void AddTransactions(UserData userData)
{
if (userData != null && userData.Transactions != null)
{
foreach (var transaction in userData.Transactions)
{
_transactionRepo.AddTransaction(transaction);
}
}
}
public int AddTransaction(Models.Transaction transactions)
{
_logger.Log(
$"[TransactionService::AddTransaction] Entering method successfully",
LogLevel.Info);
var repositoryTransactions = Mapper.Map(transactions, new Transaction());
return(_transactionRepository.AddTransaction(repositoryTransactions));
}
public void RegisterTransaction(TransactionDto transaction)
{
transactionsRepository.AddTransaction(new Data.Entities.TransactionEntity()
{
AccountId = transaction.AccountId,
Ammount = transaction.Amount,
TransactionUid = DataHelper.GenerateUniqueId(),
CustomerId = transaction.CustomerId,
TransactionsDate = transaction.TransactionDate
});
}
public void AddTransaction(string input)
{
try
{
var transaction = _transactionParser.Parse(input);
_transactionRepository.AddTransaction(transaction);
}
catch (Exception e)
{
Console.WriteLine($"Не верно указали строку: {e.Message}");
}
}
public void AddBalance(int userId, decimal amount)
{
var balance = _userRepository.GetBalance(userId) ?? 0;
balance = balance + amount;
using (var transaction = new BgsTransactionScope())
{
_userRepository.UpdateBalance(userId, balance);
_transactionRepository.AddTransaction((int)TransactionType.Deposit, userId, DateTime.Now, amount);
transaction.Complete();
};
}
public AddTransactionResponse Handle(AddTransactionRequest message)
{
_transactionRepository.AddTransaction(new TransactionEntity()
{
Amount = message.Amount,
Description = message.Description,
TransactionDate = System.DateTime.Parse(message.TransactionDate),
Tags = message.Tags,
UserId = _identity.Id
});
return(new AddTransactionResponse());
}
public void PlaceOrder(int userId)
{
var balance = _userRepository.GetBalance(userId);
var cartItems = _cartRepository.GetCartItems(userId);
var totalAmount = cartItems.Sum(x => x.Price * x.Quantity);
balance = balance - totalAmount;
if (balance < 0)
{
throw new BgsException((int)WebApiErrorCodes.NotEnoughBalance);
}
using (var transaction = new BgsTransactionScope())
{
_userRepository.UpdateBalance(userId, balance);
foreach (var item in cartItems)
{
var blocked = (int)_productRepository.GetBlockedProductQuantity(item.ProductId);
_productRepository.UpdateBlockedProductQuantity(item.ProductId, blocked - item.Quantity);
var stock = _productRepository.GetProductStock(item.ProductId) ?? 0;
if ((stock - item.Quantity) < 0)
{
throw new BgsException((int)WebApiErrorCodes.OutOfStock);
}
_productRepository.UpdateProductStock(item.ProductId, stock - item.Quantity);
}
_transactionRepository.AddTransaction((int)TransactionType.Payment, userId, DateTime.Now, totalAmount);
_cartRepository.DeleteCartItems(userId);
var orderId = _orderRepository.AddOrder(userId, (int)OrderStatus.Pending, totalAmount, DateTime.Now, DateTime.Now);
foreach (var item in cartItems)
{
var amount = item.Price * item.Quantity;
_orderRepository.AddOrderItem(orderId, item.ProductId, item.Quantity, item.Price, amount);
}
transaction.Complete();
}
}
public Ticket CreateTicket(TicketForCreationDto ticketInput)
{
double totalOdd = 1;
foreach (var match in ticketInput.SelectedMatches)
{
totalOdd *= match.SelectedOddValue;
}
var payoutTransaction =
_transactionRepository.AddTransaction(Transaction.TransactionType.Payout, ticketInput.Stake);
var stakeWithHandlingCost = ticketInput.Stake - ticketInput.Stake * 0.05;
var possiblePayout = totalOdd * stakeWithHandlingCost;
var ticket = new Ticket
{
TotalOdd = Math.Round(totalOdd, 2),
Stake = Math.Round(ticketInput.Stake, 2),
PossiblePayout = Math.Round(possiblePayout, 2),
TransactionId = payoutTransaction.Id
};
var createdTicket = _ticketRepository.AddTicket(ticket);
_transactionRepository.UpdateTicketId(payoutTransaction, ticket.Id);
if (IsWinningTicket(ticket))
{
var paymentTransaction =
_transactionRepository.AddTransaction(Transaction.TransactionType.Payment, ticket.PossiblePayout);
_transactionRepository.UpdateTicketId(paymentTransaction, ticket.Id);
}
return(createdTicket);
}
public async Task <BetResponseModel> Bet(int userId, decimal amount, decimal number)
{
var balance = await _UserRepository.GetBalance(userId);
balance = balance - amount;
if (balance < 0)
{
await _TransactionRepository.AddTransaction((int)TransactionType.Bet, userId, (int)TransactionStatus.Failed, DateTime.Now, amount);
throw new BgsException((int)WebApiErrorCodes.NotEnoughBalance);
}
var winNumber = new Random().Next(0, 36);
decimal winAmount = 0;
if (winNumber == number)
{
winAmount = amount * 36;
balance = balance + winAmount;
}
using (var transaction = new BgsTransactionScope())
{
await _UserRepository.UpdateBalance(userId, balance);
await _TransactionRepository.AddTransaction((int)TransactionType.Win, userId, (int)TransactionStatus.Success, DateTime.Now, winAmount);
transaction.Complete();
}
return(new BetResponseModel
{
WinAmount = winAmount,
WinnerNumber = winNumber
});
}
public async Task <IActionResult> Purchase(PurchaseViewModel purchaseViewModel)
{
if (ModelState.IsValid)
{
var product = _productRepository.GetProductByProductCode(
purchaseViewModel.Id, _userManager.GetUserId(User));
var isAuthorized = await _authorizationService.AuthorizeAsync(
User, product,
new OperationAuthorizationRequirement
{ Name = "Update" });
if (!isAuthorized.Succeeded)
{
return(new ChallengeResult());
}
product.Purchase(purchaseViewModel.Quantity);
_productRepository.UpdateProduct(product);
_transactionRepository.AddTransaction(new Transaction()
{
ProductId = product.Id,
ProductCode = product.ProductCode,
Name = product.Name,
Size = product.Size,
DateOfTransaction = purchaseViewModel.DatePurchased,
TypeOfTransaction = "Purchase",
Quantity = purchaseViewModel.Quantity,
Description = purchaseViewModel.Description,
OwnerID = _userManager.GetUserId(User)
});
return(RedirectToAction("Index", "Home"));
}
return(View(purchaseViewModel));
}
public async Task <IActionResult> AddTransaction(TransactionRequestViewModel transactionRequestViewModel)
{
try
{
await _transactionRepository.AddTransaction(transactionRequestViewModel.ToTransaction());
}
catch (Exception)
{
return(BadRequest(new ErrorResponseViewModel()
{
Id = (int)ErrorResponseIds.InvalidTransaction, Message = "Invalid Transaction"
}));
}
return(Ok(true));
}
public IActionResult OnPost()
{
if (ModelState.IsValid)
{
//var count = _productRepository.Add(product);
var count = _transactionRepository.AddTransaction(transaction);
if (count > 0)
{
Message = "New Product Added Successfully !";
// return RedirectToPage("/Transaction/Index");
}
}
return(Page());
}
public IActionResult CreateTransaction([FromBody] JObject value)
{
var amount = value["amount"].ToObject <double>();
if (amount <= 0)
{
return(BadRequest());
}
var createdTransaction = _transactionRepository.AddTransaction(Transaction.TransactionType.Payment, amount);
if (createdTransaction == null)
{
return(BadRequest());
}
return(Created($"transactions/create/payment/{createdTransaction.Id}",
_mapper.Map <CreatedPaymentTransactionDto>(createdTransaction)));
}
private ICollection <Transaction> AddTransaction()
{
ICollection <Transaction> transactions = new List <Transaction>();
if ((User)SelectListUser.SelectedItem == null || (User)SelectListCustomer.SelectedItem == null)
{
MessageBox.Show("Musisz wybrać Odbiorcę i użytkownika", "Błąd", MessageBoxButton.OK,
MessageBoxImage.Error);
return(null);
}
SetEdited(false);
var transactionNumber = _editedMode
? ((Transaction)this.DataContext).TransactionNumber
: _db.GetTransactionNumber();
foreach (var tool in ToolsListView.ItemsSource)
{
var price = TransactionType == TransactionType.Return
? _db.GetPriceForRent(((Tool)tool).ToolId, (DateTime)TransactionDate.SelectedDate)
: 0;
if (TransactionDate.SelectedDate == null)
{
continue;
}
var transaction = new Transaction
{
TransactionId = Guid.NewGuid(),
TransactionDate = ((DateTime)TransactionDate.SelectedDate).Add(DateTime.Now.TimeOfDay),
TransactionType = TransactionType,
TransactionNumber = transactionNumber,
Tool = (Tool)tool,
AppUser = (User)SelectListUser.SelectedItem,
Customer = (User)SelectListCustomer.SelectedItem,
PriceForRent = price
};
_db.AddTransaction(transaction);
transactions.Add(transaction);
}
return(transactions);
}
public void AddTransaction_productsAndType_Transaction()
{
var c = new List <ProductHistory>
{
new ProductHistory {
Id = 9, Name = "fef", Price = 12, Quantity = 5, TransactionId = 3
},
new ProductHistory {
Id = 10, Name = "Fsdga", Price = 51, Quantity = 5, TransactionId = 3
},
new ProductHistory {
Id = 11, Name = "Kadwcz", Price = 4, Quantity = 5, TransactionId = 3
},
new ProductHistory {
Id = 12, Name = "Srsfgba", Price = 1.25, Quantity = 10, TransactionId = 3
}
};
var expected = _repo.AddTransaction(c, TransactionType.Bought);
Assert.IsTrue(_context.Transactions.Count() == 3);
}
public async Task <ActionResult <Transaction> > PostTransaction(TransactionDto transactionDto)
{
string errMsg;
int currentMonth = DateTime.Now.Month;
int currentYear = DateTime.Now.Year;
decimal monthSum = _transactionRepository.MonthSum(transactionDto.UserId, currentMonth, currentYear);
if (Utils.ValidateAmount((monthSum + transactionDto.Amount), transactionDto.Currency))
{
Transaction transaction = _mapper.Map <Transaction>(transactionDto);
transaction.Date = DateTime.Now;
_transactionRepository.AddTransaction(transaction);
await _transactionRepository.SaveChangesAsync();
return(CreatedAtAction("PostTransaction", new { id = transaction.UserId }, new { result = transaction.Amount.ToString() + " / " + transaction.ChangeRate.ToString() + " " + transaction.Currency }));
}
else
{
errMsg = "Sobrepasa el limite admitido";
}
return(BadRequest(errMsg));
}
public async Task <IActionResult> AddTransaction(TransactionViewModel model)
{
if (!ModelState.IsValid)
{
return(StatusCode(StatusCodes.Status400BadRequest,
new Response {
Status = "Error", Message = "fill all fields"
}));
}
var claimsIdentity = User.Identity as ClaimsIdentity;
var userId = claimsIdentity.FindFirst(ClaimTypes.Name)?.Value;
var transaction = _transactionRepository.AddTransaction(new Transaction {
ServiceId = model.ServiceId, Cost = model.Cost, ApplicationUserId = userId
});
if (await _transactionRepository.SaveChangesAsync())
{
var service = await _serviceRepository.FetchService(model.ServiceId);
var network = _userNetworkRepository.GetUserNetwork(userId);
_commissionRepository.AddCommision(new Commission {
ApplicationUserId = network == null?userId:network.Network.ApplicationUserId, Amount = service.CommissionPercentage * model.Cost, TransactionId = transaction.Id
});
if (await _commissionRepository.SaveChangesAsync())
{
return(Ok(new Response {
Status = "success", Message = "Saved successfully"
}));
}
}
return(StatusCode(StatusCodes.Status500InternalServerError));
}
public IActionResult BuyProducts([FromBody] List <Product> products)
{
_lastTransaction = _transactionRepository.AddTransaction(ProductWrapper.productHistories(products), TransactionType.Bought);
_productRepository.AddProducts(products);
return(Ok());
}
public IActionResult Post(Transaction transaction)
{
var result = _transaction.AddTransaction(transaction);
return(Ok(result));
}
public void Post([FromBody] Transaction transaction)
{
Repository.AddTransaction(transaction);
}
