/// <summary>
/// updates a paymentr with BankPaymentId and success/failure information
/// </summary>
public Payment UpdatePayment(Payment paymentRequest)
{
using (var context = new PaymentsDbContext(ContextOptions))
{
try
{
Log.LogInformation($"Updating Payment: {paymentRequest.PaymentId}");
var payment = context.Payments.First(p => p.Id == paymentRequest.PaymentId);
payment.BankPaymentId = paymentRequest.BankPaymentId;
payment.IsSuccessful = payment.IsSuccessful;
payment.Message = paymentRequest.Message;
payment.PaymentStatusId = paymentRequest.Status;
payment.Updated = DateTime.UtcNow;
payment.RequestCompleted = paymentRequest.RequestCompleted.GetValueOrDefault();
context.SaveChanges();
return(paymentRequest);
}
catch (Exception ex)
{
Log.LogError(ex, $"Failed tgo Update the payment {paymentRequest.PaymentId}");
paymentRequest.Message = ex.Message;
return(paymentRequest);
}
}
}
/// <summary>
/// adds a card
/// </summary>
/// <param name="card"></param>
/// <returns></returns>
public Common.Models.Card AddCard(Common.Models.Card card, Guid userId)
{
using (var context = new PaymentsDbContext(ContextOptions))
{
try
{
var cardnumber = card.CardNumber;
card.CardNumber = MaskCardNumber(cardnumber);
var dbCard = context.Cards.FirstOrDefault(c => c.CardNumber == card.CardNumber && c.CVC == card.CVC && c.UserId == userId && c.ExpiryDate == card.ExpiryDate);
if (dbCard == null || string.IsNullOrWhiteSpace(dbCard.Id.ToString()))
{
card.Id = Guid.NewGuid();
var newCard = MyMapper.Map <Models.Card>(card);
newCard.UserId = userId;
context.Cards.Add(newCard);
context.SaveChanges();
}
else
{
card.Id = dbCard.Id;
}
return(card);
//var toReturn = MyMapper.Map<Common.Models.Card>(result);
//return toReturn;
}
catch (Exception ex)
{
Log.LogError(ex, "");
Log.LogError(ex, $"Failed to create user");
throw ex;
}
}
}
public PaymentsController(PaymentsDbContext context, IRepository repository, IMapper mapper)
{
_context = context;
_repository = repository;
_mapper = mapper;
_retryPolicy = Policy.Handle <Exception>().RetryAsync(retryCount: MaxRetries);
}
public PaymentRepository(PaymentsDbContext paymentsDbContext, IMapper mapper, ILogger <PaymentRepository> logger, PaymentReadRepository paymentReadRepository)
{
_paymentReadRepository = paymentReadRepository;
_paymentsDbContext = paymentsDbContext;
_mapper = mapper;
_logger = logger;
}
/// <summary>
/// Adds a new payment
/// </summary>
public Common.Models.Payment StorePayment(Common.Models.Payment paymentRequest)
{
using (var context = new PaymentsDbContext(ContextOptions))
{
try
{
var dbPayment = context.Payments.FirstOrDefault(c => c.Id == paymentRequest.PaymentId);
if (dbPayment == null || string.IsNullOrWhiteSpace(dbPayment.Id.ToString()))
{
Log.LogInformation($"Adding the payment to the database: {paymentRequest.PaymentId}");
var newPayment = MyMapper.Map <Models.Payment>(paymentRequest);
context.Payments.Add(newPayment);
context.SaveChanges();
}
else
{
Log.LogWarning($"Duplicate Payment: {paymentRequest.PaymentId}");
paymentRequest.Status = Common.Enums.PaymentStatus.DuplicateRequest;
paymentRequest.IsSuccessful = false;
paymentRequest.Message = $"Duplicate payment request";
}
return(paymentRequest);
}
catch (Exception ex)
{
Log.LogError(ex, "Failed to store payment");
paymentRequest.Status = PaymentStatus.PaymentNotStored;
return(paymentRequest);
}
}
}
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline.
public void Configure(IApplicationBuilder app, IWebHostEnvironment env, PaymentsDbContext db)
{
app.UseCors("AllowOrigin");
if (env.IsDevelopment())
{
app.UseDeveloperExceptionPage();
}
//Swagger
app.UseSwagger();
app.UseSwaggerUI(c =>
{
c.DefaultModelsExpandDepth(-1); // Hide the SCHEMAS
c.SwaggerEndpoint("/swagger/v1/swagger.json", "Payments API v1");
});
//
//Db creation with execution
//db.Database.EnsureCreated();
app.UseHttpsRedirection();
app.UseRouting();
app.UseAuthorization();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
}
/// <summary>
/// adds a user
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public Common.Models.User AddUser(Common.Models.User user)
{
using (var context = new PaymentsDbContext(ContextOptions))
{
try
{
var dbUser = context.Users.FirstOrDefault(u => u.Fullname == user.Fullname && u.DateOfBirth == user.DateOfBirth);
if (dbUser == null || string.IsNullOrWhiteSpace(dbUser.Id.ToString()))
{
user.Id = Guid.NewGuid();
context.Users.Add(MyMapper.Map <Models.User>(user));
context.SaveChanges();
}
else
{
user.Id = dbUser.Id;
}
return(user);
}
catch (Exception ex)
{
Log.LogError(ex, $"Failed to create user");
throw ex;
}
}
}
private static void Main(string[] args)
{
var connectionString = ConfigurationManager.AppSettings["defaultConnection"];
if (args.Length > 0)
{
connectionString = args[0];
}
// Use ConferenceContext as entry point for dropping and recreating DB
using (var context = new ConferenceContext()) {
if (context.Database.Exists())
{
context.Database.Delete();
}
context.Database.Create();
}
Database.SetInitializer <EventStoreDbContext>(null);
Database.SetInitializer <MessageLogDbContext>(null);
Database.SetInitializer <BlobStorageDbContext>(null);
Database.SetInitializer <ConferenceRegistrationDbContext>(null);
Database.SetInitializer <RegistrationProcessManagerDbContext>(null);
Database.SetInitializer <PaymentsDbContext>(null);
DbContext[] contexts =
{
new EventStoreDbContext(connectionString),
new MessageLogDbContext(connectionString),
new BlobStorageDbContext(connectionString),
new PaymentsDbContext(connectionString),
new RegistrationProcessManagerDbContext(connectionString),
new ConferenceRegistrationDbContext(connectionString)
};
foreach (var context in contexts)
{
var adapter = (IObjectContextAdapter)context;
var script = adapter.ObjectContext.CreateDatabaseScript();
context.Database.ExecuteSqlCommand(script);
context.Dispose();
}
using (var context = new ConferenceRegistrationDbContext(connectionString)) {
ConferenceRegistrationDbContextInitializer.CreateIndexes(context);
}
using (var context = new RegistrationProcessManagerDbContext(connectionString)) {
RegistrationProcessManagerDbContextInitializer.CreateIndexes(context);
}
using (var context = new PaymentsDbContext(connectionString)) {
PaymentsReadDbContextInitializer.CreateViews(context);
}
MessagingDbInitializer.CreateDatabaseObjects(connectionString, "SqlBus");
}
/// <summary>
/// Gets a payment by PAymentId
/// </summary>
/// <param name="paymentId"></param>
/// <returns></returns>
public Payment GetPayment(Guid paymentId)
{
using (var context = new PaymentsDbContext(ContextOptions))
{
try
{
var defaultResponse = new Common.Models.Payment
{
PaymentId = paymentId,
Status = PaymentStatus.RequestDoesNotExist,
Message = $"The payment: {paymentId} does not exist"
};
var payment = (from p in context.Payments
join c in context.Cards on p.CardId equals c.Id
join u in context.Users on c.UserId equals u.Id
where p.Id == paymentId
select new Common.Models.Payment
{
Amount = p.Amount,
BankPaymentId = p.BankPaymentId,
CurrencyCode = p.CurrencyCode,
FullName = u.Fullname,
IsSuccessful = p.IsSuccessful,
Message = p.Message,
PaymentId = p.Id,
RequestCompleted = p.RequestCompleted,
RequestDate = p.RequestDate,
Status = p.PaymentStatusId,
CardExpiryDate = c.ExpiryDate,
CardNumber = c.CardNumber,
CVC = c.CVC
}).FirstOrDefault();
if (payment == null)
{
payment = defaultResponse;
}
return(payment);
}
catch (Exception ex)
{
Log.LogError(ex, $"Failed to get payment information {paymentId}");
return(new Payment
{
PaymentId = paymentId,
IsSuccessful = false,
Status = PaymentStatus.Error,
Message = ex.Message
});
}
}
}
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;
}
}
public EfPaymentsRepository(PaymentsDbContext dbContext)
{
_dbContext = dbContext;
}
public PaymentService(PaymentsDbContext context)
: base(context)
{
}
public PaymentMockPaidConsumer(PaymentsDbContext paymentsDbContext)
{
_paymentsDbContext = paymentsDbContext;
}
public TransactionRepository(PaymentsDbContext context, IMediator mediator) : base(context, mediator)
{
}
public PaymentRepository(PaymentsDbContext context)
{
_context = context;
}
public PaymentMockRequiredConsumer(PaymentsDbContext paymentsDbContext)
{
_paymentsDbContext = paymentsDbContext;
}
public BankResponseRepository(PaymentsDbContext paymentsDbContext, ILogger <BankResponseRepository> logger)
{
_paymentsDbContext = paymentsDbContext;
_logger = logger;
}
public ProviderSettingTenantRepository(PaymentsDbContext context, IMediator mediator) : base(context, mediator)
{
}
public PaymentsController(PaymentsDbContext paymentsDbContext)
{
_paymentsDbContext = paymentsDbContext;
}
public AppSettingRepository(PaymentsDbContext context, IMediator mediator) : base(context, mediator)
{
}
public ReadService(PaymentsDbContext context)
{
_context = context;
}
public OrderPlacedEventConsumer(PaymentsDbContext paymentsDbContext)
{
_paymentsDbContext = paymentsDbContext;
}
public PaymentsController(PaymentsDbContext quotesDbContext)
{
this._quotesDbContext = quotesDbContext;
}
public ProviderRepository(PaymentsDbContext context, IMediator mediator) : base(context, mediator)
{
}
public PaymentMethodRepository(PaymentsDbContext context, IMediator mediator) : base(context, mediator)
{
}
public WriteService(PaymentsDbContext context)
{
_context = context;
}
public PaymentsMockController(PaymentsDbContext paymentsDbContext, IBus bus)
{
_paymentsDbContext = paymentsDbContext;
_bus = bus;
}
