public async Task <IActionResult> PutPayment(int id, Payment payment)
{
if (id != payment.paymentId)
{
return(BadRequest());
}
_context.Entry(payment).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaymentExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutProductType(Guid id, ProductType productType)
{
if (id != productType.ID)
{
return(BadRequest());
}
_context.Entry(productType).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!ProductTypeExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutCountry(Guid id, Country country)
{
if (id != country.ID)
{
return(BadRequest());
}
_context.Entry(country).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CountryExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task <IActionResult> PutPaymentDetail([FromRoute] Guid id, [FromBody] PaymentDetail paymentDetail)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != paymentDetail.ID)
{
return(BadRequest());
}
_context.Entry(paymentDetail).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!PaymentDetailExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public async Task Create(Payment payment)
{
if (payment != null)
{
_dbContext.Payments.Add(payment);
await _dbContext.SaveChangesAsync();
}
}
//Add Payment
public async Task <Payments> AddAsync(Payments payment)
{
payment.CreatedDate = DateTime.Now;
_context.Set <Payments>().Add(payment);
await _context.SaveChangesAsync();
return(payment);
}
public async Task <ActionResult> PayByCreditCard(PaymentInputInfo info)
{
var paymentSession = await context.PaymentSessions.FirstOrDefaultAsync(session => session.SessionId == info.SessionId);
if (paymentSession.SessionRegistrationTime.AddMinutes(paymentSession.LifeSpanInMinute) < DateTime.Now)
{
return(BadRequest("Payment session is out of time"));
}
Receipt receipt = new Receipt
{
Id = Guid.NewGuid(),
CustomerName = info.Card.HolderName,
Product = paymentSession.PaymentAppointment,
OperationTime = DateTime.Now,
Seller = info.Seller,
Cost = paymentSession.Cost
};
context.PaymentSessions.Remove(paymentSession);
context.Receipts.Add(receipt);
await context.SaveChangesAsync();
await SendNotificationToShop(receipt);
return(Ok($"Congratulations, {info.Card.HolderName}, you are a happy owner of {paymentSession.PaymentAppointment}!"));
}
public async Task <IActionResult> Payed(PayedInput input)
{
PayedInfo info = new PayedInfo(input.PayedDesc, input.Payer, DateTime.Now, input.PayDecimal, input.OrderId);
using (var transcation = _paymentDbContext.Database.BeginTransaction(_capBus, true))
{
try
{
await _paymentDbContext.AddAsync(info);
_capBus.Publish("Payment.services.Payed", info);
var result = await _paymentDbContext.SaveChangesAsync();
// transcation.Commit();
}
catch (Exception e)
{
await transcation.RollbackAsync();
return(BadRequest());
}
return(Ok());
}
}
public async Task <bool> AddTransaction(Transaction transaction)
{
var transactionDb = _mapper.Map <Models.Transaction>(transaction);
transactionDb.Date = DateTime.Now;
var result = _paymentDbContext.Transaction.Add(transactionDb);
if (result.State != Microsoft.EntityFrameworkCore.EntityState.Added)
{
return(false);
}
await _paymentDbContext.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> PostPayment([FromBody] PostPaymentRequest request)
{
// todo: check if customer exists in database
var creditCards = await DbContext.GetCreditCardByCardHolderName(request.CardHolderName).ToListAsync();
var creditCard = default(CreditCard);
if (creditCards.Count > 1)
{
creditCard = creditCards.FirstOrDefault(item => item.CardNumber == request.CardNumber);
if (creditCard == null)
{
return(BadRequest(string.Format("There isn't record for credit card with last 4 digits: {0}.", request.CardNumber)));
}
}
else if (creditCards.Count == 1)
{
creditCard = creditCards.First();
}
else
{
return(BadRequest(string.Format("There isn't record for credit card with last 4 digits: {0}.", request.CardNumber)));
}
// todo: check credit card info in database
if (!creditCard.IsValid(request))
{
return(BadRequest(string.Format("There is invalid data for credit card in this transaction.")));
}
// todo: check if customer has available credit (limit)
if (!creditCard.HasFounds(request))
{
return(BadRequest(string.Format("There isn't founds to approve this transaction.")));
}
var txn = new PaymentTransaction
{
PaymentTransactionID = Guid.NewGuid(),
CreditCardID = creditCard.CreditCardID,
ConfirmationID = Guid.NewGuid(),
Amount = request.Amount,
PaymentDateTime = DateTime.Now
};
DbContext.PaymentTransactions.Add(txn);
creditCard.AvailableFounds -= request.Amount;
await DbContext.SaveChangesAsync();
return(Ok(new { txn.ConfirmationID, creditCard.Last4Digits }));
}
public async Task ReturnPaymentForGivenId()
{
var payment = _fixture.Create <Payment>();
await _paymentContext.Payments.AddAsync(payment);
await _paymentContext.SaveChangesAsync();
var paymentAInDb = await _paymentRepository.GetAsync(payment.Id);
paymentAInDb.Should().NotBeNull();
}
public async Task Handle(UpdateUserIntegrationEvent @event)
{
var customer = await _context.Customers.SingleOrDefaultAsync(x => x.Id == @event.UserId);
if (customer != null)
{
customer = _mapper.Map(@event, customer);
_context.Customers.Update(customer);
await _context.SaveChangesAsync();
}
}
public async Task <Read.BankInfo> CreateBankInfoAsync(Write.BankInfo bankInfo)
{
var bankDataModel = new Data.Model.BankInfo {
BankCode = bankInfo.BankCode, Url = bankInfo.Url
};
_context.BankInfos.Add(bankDataModel);
await _context.SaveChangesAsync();
return(ConvertBankInfoDataModelToReadModel(bankDataModel));
}
public async Task <PaymentResult> MakePayment(PaymentDetailsDTO paymentDetails)
{
var newPayment = new PaymentDetail
{
CardNumber = paymentDetails.CardNumber,
CVV = paymentDetails.CVV,
CardOwnerName = paymentDetails.CardOwnerName,
ExpirationDate = paymentDetails.ExpirationDate
};
await _context.PaymentDetails.AddAsync(newPayment);
await _context.SaveChangesAsync();
return(new PaymentResult()
{
IsComplete = true
});
}
public async Task <ActionResult <Guid> > CreateSession([FromBody] PaymentSessionInputInfo info)
{
if (info == null)
{
return(BadRequest());
}
PaymentSession paymentSession = new PaymentSession
{
Cost = info.Sum,
SessionId = Guid.NewGuid(),
PaymentAppointment = info.PaymentAppointement,
SessionRegistrationTime = DateTime.Now,
LifeSpanInMinute = 60,
};
context.PaymentSessions.Add(paymentSession);
await context.SaveChangesAsync();
return(Ok(paymentSession.SessionId));
}
public static async Task Seed(PaymentDbContext dbContext)
{
await dbContext.Set <PaymentMethod>().AddAsync(new PaymentMethod
{
Id = new System.Guid("c50683db-d227-4856-b777-ea07e030d926"),
Code = "AM" // AMEX
});
await dbContext.Set <PaymentMethod>().AddAsync(new PaymentMethod
{
Id = new System.Guid("aae5885e-682b-42e8-b230-7ad2dad55331"),
Code = "MC" // MasterCard
});
await dbContext.Set <PaymentMethod>().AddAsync(new PaymentMethod
{
Id = new System.Guid("7fa09019-f0c4-4479-b9fd-fae9652c4901"),
Code = "CSH" // Cash
});
await dbContext.SaveChangesAsync();
}
public async Task AddAsync(Payment payment)
{
await _paymentContext.Payments.AddAsync(payment);
await _paymentContext.SaveChangesAsync();
}
public async Task <IActionResult> PostPaymentAsync([FromBody] PostPaymentRequest request)
{
Logger?.LogDebug("'{0}' has been invoked", nameof(PostPaymentAsync));
var creditCards = await DbContext.GetCreditCardByCardHolderName(request.CardHolderName).ToListAsync();
var creditCard = default(CreditCard);
var last4Digits = request.CardNumber.Substring(request.CardNumber.Length - 4);
if (creditCards.Count > 1)
{
creditCard = creditCards.FirstOrDefault(item => item.CardNumber == request.CardNumber);
}
else if (creditCards.Count == 1)
{
creditCard = creditCards.First();
}
if (creditCard == null)
{
return(BadRequest(string.Format("There is not record for credit card with last 4 digits: {0}.", last4Digits)));
}
/* Check credit card information */
if (!creditCard.IsValid(request))
{
return(BadRequest(string.Format("Invalid information for card payment.")));
}
/* Check if customer has available credit (limit) */
if (!creditCard.HasFounds(request))
{
return(BadRequest(string.Format("There are no founds to approve the payment.")));
}
using (var txn = await DbContext.Database.BeginTransactionAsync())
{
try
{
var paymentTxn = new PaymentTransaction
{
PaymentTransactionID = Guid.NewGuid(),
CreditCardID = creditCard.CreditCardID,
ConfirmationID = Guid.NewGuid(),
Amount = request.Amount,
PaymentDateTime = DateTime.Now
};
DbContext.PaymentTransactions.Add(paymentTxn);
creditCard.AvailableFounds -= request.Amount;
await DbContext.SaveChangesAsync();
txn.Commit();
Logger?.LogInformation("The payment for card with last 4 digits: '{0}' was successfully. Confirmation #: {1}", last4Digits, paymentTxn.ConfirmationID);
var response = new PaymentResponse
{
ConfirmationID = paymentTxn.ConfirmationID,
PaymentDateTime = paymentTxn.PaymentDateTime,
Last4Digits = creditCard.Last4Digits
};
return(Ok(response));
}
catch (Exception ex)
{
Logger?.LogCritical("There was an error on '{0}': {1}", nameof(PostPaymentAsync), ex);
txn.Rollback();
return(new ObjectResult(ex.Message)
{
StatusCode = (int)HttpStatusCode.InternalServerError
});
}
}
}
public async Task AddAsync(TEntity model)
{
_dbSet.Add(model);
await _context.SaveChangesAsync();
}
public async Task <bool> SaveChangesAsync()
{
return((await _paymentDbContext.SaveChangesAsync()) > 0);
}
/// <inheritdoc />
public async Task <int> SavePayment(Payment payment,
CancellationToken cancellationToken)
{
paymentDbContext.Payments.Add(payment);
return(await paymentDbContext.SaveChangesAsync(cancellationToken));
}
