public async Task <ActionResult> UpdatePaymentStatus(int paymentId)
{
try
{
if (paymentId == 0)
{
return(BadRequest("PaymentId Is Invalid"));
}
var response = await Task.Run(() => _context.PaymentData.Where(p => p.PaymentId == paymentId).Include(i => i.PaymentState).FirstOrDefault());
if (response != null)
{
var paymentState = await Task.Run(() => _context.PaymentState.ToList());
int paymnetstateId = Convert.ToInt32(PaymentStates.processed);
response.PaymentState = paymentState.ToList().Where(s => s.PaymentStateId == paymnetstateId).FirstOrDefault();
_context.Entry(response).State = EntityState.Modified;
await _context.SaveChangesAsync();
return(Ok(response));
}
}
catch (Exception)
{
return(StatusCode(int.Parse(HttpStatusCode.InternalServerError.ToString())));
}
return(Ok("Data Not Found"));
}
public async Task <IEnumerable <TransactionDTO> > CreateTransactions(IEnumerable <TransactionDTO> transaction)
{
await _context.Transactions.AddRangeAsync(transaction);
await _context.SaveChangesAsync();
return(transaction);
}
public async Task Consume(ConsumeContext <OrderPlacedEvent> context)
{
var payment = new Payment()
{
Amount = context.Message.Amount,
OrderId = context.Message.OrderId,
PaymentMethod = context.Message.PaymentMethod,
PaymentStatus = PaymentStatus.New,
PaymentReference = context.Message.PaymentReference
};
_paymentsDbContext.Payments.Add(payment);
await _paymentsDbContext.SaveChangesAsync();
await context.Publish(new PaymentCreatedEvent()
{
PaymentId = payment.Id,
PaymentReference = payment.PaymentReference,
OrderId = payment.OrderId,
});
// todo tempoary, should start correct saga here...
if (context.Message.PaymentMethod == PaymentMethod.OnDelivery.Name)
{
payment.PaymentStatus = PaymentStatus.Completed;
await _paymentsDbContext.SaveChangesAsync();
await context.Publish(new PaymentCompletedEvent() // todo sending PaymentCompleted for order to be paid on delivery is a lie...
{
OrderId = payment.OrderId,
PaymentId = payment.Id,
PaymentReference = payment.PaymentReference
});
}
if (context.Message.PaymentMethod == PaymentMethod.PaymentProvider.Name)
{
await context.Publish(new PaymentMockRequired()
{
Amount = payment.Amount,
Description = $"Płatność za zamówienie {payment.OrderId} dla pjmicrostore",
PaymentReference = payment.PaymentReference
});
}
}
public async Task CreatePayment(CreatePaymentRequest createPaymentRequest)
{
var payment = new Payment
{
MerchantId = createPaymentRequest.MerchantId,
Amount = createPaymentRequest.Amount,
Currency = createPaymentRequest.Currency
};
await _context.AddAsync <Payment>(payment);
await _context.SaveChangesAsync();
}
public async Task Consume(ConsumeContext <PaymentMockRequired> context)
{
Thread.Sleep(5000 + context.SentTime.Value.Second); // todo "random" waiting time
_paymentsDbContext.MockPayments.Add(new MockPayement()
{
Amount = context.Message.Amount,
PaymentReference = context.Message.PaymentReference,
PaymentDescription = context.Message.Description,
PaymentStatus = PaymentStatus.New,
ProviderReference = Guid.NewGuid()
});
await _paymentsDbContext.SaveChangesAsync();
}
public async Task Consume(ConsumeContext <PaymentMockPaid> context)
{
var payment = _paymentsDbContext.Payments.FirstOrDefault(x => x.PaymentReference == context.Message.PaymentReference);
payment.PaymentStatus = PaymentStatus.Completed;
await context.Publish(new PaymentCompletedEvent()
{
OrderId = payment.OrderId,
PaymentId = payment.Id,
PaymentReference = payment.PaymentReference
});
await _paymentsDbContext.SaveChangesAsync();
}
public async Task <bool> ProcessPayments(PaymentData reqObj, PaymentsDbContext context)
{
try
{
var paymentState = await Task.Run(() => context.PaymentState.ToList());
reqObj.PaymentState = new PaymentState();
int paymnetstateId = Convert.ToInt32(PaymentStates.pending);
reqObj.PaymentState = paymentState.ToList().Where(s => s.PaymentStateId == paymnetstateId).FirstOrDefault();
context.PaymentData.Add(reqObj);
await context.SaveChangesAsync();
return(true);
}
catch (Exception ex)
{
throw;
}
}
// IPaymentRepository
private async Task AddAsync(Payment payment)
{
try
{
var entity = _mapper.Map <Entities.Payment>(payment);
await _paymentsDbContext.AddAsync(entity);
await _paymentsDbContext.SaveChangesAsync();
var paymentRead = _mapper.Map <PaymentReadModel>(payment);
paymentRead.Status = PaymentStatus.CREATED;
paymentRead.CardNumber = MaskCardNumber(payment.CardNumber);
await _paymentReadRepository.InsertOneAsync(paymentRead);
}
catch (Exception e)
{
_logger.LogError(e, "Error while trying to add payment to database.");
throw;
}
}
public async Task SaveAsync(LoggedEvent @event)
{
@event.TimeStamp = DateTime.UtcNow;
_dbContext.LoggedEvents.Add(@event);
await _dbContext.SaveChangesAsync();
}
public virtual async Task SaveBankResponseAsync(BankResponse bankResponse)
{
await _paymentsDbContext.BankResponses.AddAsync(bankResponse);
await _paymentsDbContext.SaveChangesAsync();
}
public async Task AddPaymentAsync(Payment payment)
{
await _dbContext.Payments.AddAsync(payment);
await _dbContext.SaveChangesAsync();
}
