public override async Task <DAL.App.DTO.Payment> FindAsync(params object[] id)
{
var culture = Thread.CurrentThread.CurrentUICulture.Name.Substring(0, 2).ToLower();
var payment = await RepositoryDbSet.FindAsync(id);
if (payment != null)
{
await RepositoryDbContext.Entry(payment)
.Reference(c => c.PaymentMethod)
.LoadAsync();
await RepositoryDbContext.Entry(payment.PaymentMethod)
.Reference(c => c.PaymentMethodValue)
.LoadAsync();
await RepositoryDbContext.Entry(payment.PaymentMethod.PaymentMethodValue)
.Collection(b => b.Translations)
.Query()
.Where(t => t.Culture == culture)
.LoadAsync();
}
return(PaymentMapper.MapFromDomain(payment));
}
public async Task <List <Payment> > AllForUserAsync(int userId)
{
return((await Uow.Payments
.AllForUserAsync(userId))
.Select(e => PaymentMapper
.MapFromDAL(e)).ToList());
}
public DataService()
{
//context = new HouseHoldContext();
//var hhm = context.HouseHoldMoneys.
mapperHHM = new HouseHoldMoneyMapper();
mapperP = new PaymentMapper();
}
/// <summary>
/// Initializes a DataAccessFacade for accessing a MS SQL database
/// </summary>
/// <param name="test">For integration tests, set test = true to use test database</param>
public DataAccessFacade(bool test = false)
{
if (!test)
{
//take the database information from a textfile.
connectionString = File.ReadAllText("C:\\ConnectString.txt");
}
else
{
connectionString =
@"Data Source=localhost\SQLEXPRESS;Initial Catalog=LTTEST;Integrated Security=True";
}
//Creates a new instance of the mappers with the connection information
paymentMapper = new PaymentMapper(connectionString);
customerMapper = new CustomerMapper(connectionString);
supplierMapper = new SupplierMapper(connectionString);
bookingMapper = new BookingMapper(connectionString);
paymentRuleMapper = new PaymentRuleMapper(connectionString);
PartyMapper partyMapper = new PartyMapper();
partyMapper.CustomerMapper = customerMapper;
partyMapper.SupplierMapper = supplierMapper;
paymentMapper.PartyMapper = partyMapper;
bookingMapper.CustomerMapper = customerMapper;
bookingMapper.SupplierMapper = supplierMapper;
paymentRuleMapper.CustomerMapper = customerMapper;
paymentRuleMapper.SupplierMapper = supplierMapper;
customerMapper.ReadAll();
supplierMapper.ReadAll();
}
public void MapperMapsPaymentToPaymentDto()
{
var guid = new Guid("24b542a8-4825-4089-ace6-6c0ef8bd56a8");
var payment = new Payment
{
Amount = 1,
Currency = "GBP",
Card = new Card
{
CardNumber = "1234123412341234",
Cvv = 123,
ExpiryMonth = 12,
ExpiryYear = 20
},
Id = guid,
IsSuccessful = true
};
var mapper = new PaymentMapper(new CardMapper());
var mappedObject = mapper.Map(payment);
mappedObject.Should().NotBeNull();
mappedObject.Id.Should().Be(guid);
mappedObject.IsSuccessful.Should().BeTrue();
mappedObject.Card.Should().NotBeNull();
mappedObject.Card.Cvv.Should().Be(123);
mappedObject.Card.CardNumber.Should().Be("1234123412341234");
mappedObject.Card.ExpiryMonth.Should().Be(12);
mappedObject.Card.ExpiryYear.Should().Be(20);
mappedObject.Amount.Should().Be(1);
mappedObject.Currency.Should().Be("GBP");
}
public void MapperMapsEveryPropertyProperly()
{
var id = new Guid("24b542a8-4825-4089-ace6-6c0ef8bd56a8");
var paymentRequest = new PaymentRequest
{
Amount = 1,
Currency = "GBP",
Card = new Card
{
CardNumber = "1234123412341234",
Cvv = 123,
ExpiryMonth = 12,
ExpiryYear = 20
}
};
var paymentMapper = new PaymentMapper();
var mappedObject = paymentMapper.Map(id, true, paymentRequest);
mappedObject.Should().NotBeNull();
mappedObject.Id.Should().Be(id);
mappedObject.IsSuccessful.Should().BeTrue();
mappedObject.Card.Should().NotBeNull();
mappedObject.Card.Cvv.Should().Be(123);
mappedObject.Card.CardNumber.Should().Be("1234123412341234");
mappedObject.Card.ExpiryMonth.Should().Be(12);
mappedObject.Card.ExpiryYear.Should().Be(20);
mappedObject.Amount.Should().Be(1);
mappedObject.Currency.Should().Be("GBP");
}
/// <summary>
/// Initializes a DataAccessFacade for accessing a MS SQL database
/// </summary>
/// <param name="test">For integration tests, set test = true to use test database</param>
public DataAccessFacade(bool test = false)
{
if (!test)
{
//take the database information from a textfile.
connectionString = File.ReadAllText("C:\\ConnectString.txt");
}
else
{
connectionString =
@"Data Source=localhost\SQLEXPRESS;Initial Catalog=LTTEST;Integrated Security=True";
}
//Creates a new instance of the mappers with the connection information
paymentMapper = new PaymentMapper(connectionString);
customerMapper = new CustomerMapper(connectionString);
supplierMapper = new SupplierMapper(connectionString);
bookingMapper = new BookingMapper(connectionString);
paymentRuleMapper = new PaymentRuleMapper(connectionString);
PartyMapper partyMapper = new PartyMapper();
partyMapper.CustomerMapper = customerMapper;
partyMapper.SupplierMapper = supplierMapper;
paymentMapper.PartyMapper = partyMapper;
bookingMapper.CustomerMapper = customerMapper;
bookingMapper.SupplierMapper = supplierMapper;
paymentRuleMapper.CustomerMapper = customerMapper;
paymentRuleMapper.SupplierMapper = supplierMapper;
customerMapper.ReadAll();
supplierMapper.ReadAll();
}
public void MapperMapsNullPaymentToEmptyDto()
{
var mapper = new PaymentMapper(null);
var mappedObject = mapper.Map(null);
mappedObject.Should().NotBeNull();
mappedObject.Should().BeEquivalentTo(PaymentDto.Empty);
}
public override async Task <List <DAL.App.DTO.Payment> > AllAsync()
{
return(await RepositoryDbSet
.Include(p => p.PaymentMethod)
.ThenInclude(p => p.PaymentMethodValue)
.ThenInclude(t => t.Translations)
.Select(e => PaymentMapper.MapFromDomain(e))
.ToListAsync());
}
public async Task <List <Payment> > AllForUserAsync(int userId)
{
return(await RepositoryDbSet
.Include(p => p.PaymentMethod)
.ThenInclude(p => p.PaymentMethodValue)
.ThenInclude(t => t.Translations)
.Where(c => c.Bill.WorkObject.AppUsersOnObject.Any(q => q.AppUserId == userId))
.Select(e => PaymentMapper.MapFromDomain(e)).ToListAsync());
}
public async Task <Payment> FindForUserAsync(int id, int userId)
{
var payment = await RepositoryDbSet
.Include(p => p.PaymentMethod)
.ThenInclude(p => p.PaymentMethodValue)
.ThenInclude(t => t.Translations)
.FirstOrDefaultAsync(m => m.Id == id && m.Bill.WorkObject.AppUsersOnObject.Any(q => q.AppUserId == userId));
return(PaymentMapper.MapFromDomain(payment));
}
public async Task <IEnumerable <GetPaymentsResponse> > GetAll(Merchant merchant)
{
if (merchant == null)
{
return(null);
}
var result = await _paymentRepository.GetAllByMerchant(merchant);
return(result.Select(x => PaymentMapper.MapGetPaymentsResponse(x, _encryptionProvier)));
}
public async Task <IActionResult> GetPayments()
{
var options = new ChargeListOptions
{
Limit = 100
};
var service = new ChargeService();
StripeList <Charge> charges = await service.ListAsync(
options
);
return(new OkObjectResult(new { success = "true", payments = PaymentMapper.Map(charges.Data) }));
}
public async Task <CreatePaymentResponse> CreatePayment(CreatePaymentRequest request, Merchant merchant)
{
try
{
if (merchant == null)
{
return(null);
}
_log.LogInformation($"Requesting bank for merchant {merchant.Id} : {request.Amount:C2}");
var bankResponse = await _bankGateway.SubmitPayment(PaymentMapper.MapGatewayRequest(request));
_log.LogInformation($"Bank response for merchant {merchant.Id} : {bankResponse.Status} ");
var payment = await _paymentRepository.Add(PaymentMapper.MapPayment(bankResponse, merchant, _encryptionProvier));
var isPaymentSuccessfull = bankResponse.Status == BankGatewayPaymentStatus.Successfull;
var result = new CreatePaymentResponse {
IsSuccessfull = isPaymentSuccessfull
};
if (isPaymentSuccessfull)
{
result.PaymentId = payment.Id;
}
else
{
result.ErrorMessage = "Unable to process payment with Bank";
}
_log.LogInformation($"Created Payment for merchant {merchant.Id} : {result.PaymentId} ");
return(result);
}
catch (Exception ex)
{
_log.LogError("Unabl to process paument", ex);
return(new CreatePaymentResponse
{
IsSuccessfull = false,
ErrorMessage = "An unexpected error occured, please try again later or contact support"
});
}
}
public PaymentController(
IBankService bankService,
PaymentMapper paymentMapper,
AddEntityCommand addEntityCommand,
GetPaymentByIdQuery getPaymentByIdQuery,
PaymentViewModelBuilder paymentViewModelBuilder,
GetAllPaymentsQuery getAllPaymentsQuery)
{
this.bankService = bankService;
this.paymentMapper = paymentMapper;
this.addEntityCommand = addEntityCommand;
this.getPaymentByIdQuery = getPaymentByIdQuery;
this.paymentViewModelBuilder = paymentViewModelBuilder;
this.getAllPaymentsQuery = getAllPaymentsQuery;
}
public ActionResult Index(int pageId = 1)
{
int countPerPage = 10;
this.TempData["CurrentPage"] = pageId;
if (CurrentUser.IsInRole(UserRoles.Admin))
{
var transactions = ServiceFactory.GetPaymentService().GetDataPerPage(null, pageId, countPerPage);
return(this.View(PaymentMapper.GetPaymentTransactionsToEdit(transactions)));
}
else
{
var transactions = ServiceFactory.GetPaymentService().GetDataPerPage(CurrentUser.Id, pageId, countPerPage);
return(this.View(PaymentMapper.GetPaymentTransactionsToEdit(transactions)));
}
}
public void MapperMapsNullToEmptyObject()
{
var paymentMapper = new PaymentMapper();
var mappedObject = paymentMapper.Map(new Guid("24b542a8-4825-4089-ace6-6c0ef8bd56a8"), false, null);
mappedObject.Should().NotBeNull();
mappedObject.Id.Should().Be(Guid.Empty);
mappedObject.IsSuccessful.Should().BeFalse();
mappedObject.Card.Should().NotBeNull();
mappedObject.Card.Cvv.Should().Be(default(int));
mappedObject.Card.CardNumber.Should().Be(default(string));
mappedObject.Card.ExpiryMonth.Should().Be(default(int));
mappedObject.Card.ExpiryYear.Should().Be(default(int));
mappedObject.Amount.Should().Be(default(double));
mappedObject.Currency.Should().Be(default(string));
}
public async Task <PaymentProcessResponse> ProcessPayment(Payment payment)
{
try
{
var inputData = new PaymentMapper().Map(payment);
var response = await client.Payment.Process(inputData);
return(new PaymentResponseMapper().Map(response.Content));
}
catch (BankApiHttpException ex)
{
var responseContent = await ex.Response.Content.ReadAsStringAsync();
return(new PaymentErrorResponseMapper().Map(
JsonConvert.DeserializeObject <PaymentResponse>(responseContent)));
}
}
public async Task <PaymentProcessResponse> Handle(PaymentProcessCommand request,
CancellationToken cancellationToken)
{
var payment = new PaymentMapper().Map(request);
var response = await bank.ProcessPayment(payment);
payment.TransactionId = response.TransactionId;
payment.TransactionStatus = response.Status;
if (response is PaymentProcessErrorResponse errorResponse)
{
payment.Reason = errorResponse.Reason;
// TODO - Logger error message with an Event
}
var newPayment = await repository.AddAsync(payment);
return(new PaymentProcessResponseMapper().Map(newPayment));
}
public ActionResult Create(PaymentViewModel pvm)
{
pvm.OrderDate = DateTime.Now;
cart = (List <Item>)TempData["cart"];
if (ModelState.IsValid)
{
Payment _payment = PaymentMapper.To_Payment_Create_ViewModel(pvm);
_repository.Create(_payment);
_repository.Save();
List <Order> order = OrderMapper.To_order_Create_Cart(cart, _payment.PaymentID);
foreach (Order ord in order)
{
_repoorder.Create(ord);
_repoorder.Save();
EntitieServices.EntitiProductShop.Product pr = _repositoryproduct.Select(ord.ProductId);
pr.Quantity = pr.Quantity - ord.ProductQuantity;
_repositoryproduct.Save();
}
}
Session["cart"] = null;
return(RedirectToAction("Index", "Products"));
}
/// <summary>
/// Update Payment Status
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <IEnumerable <Payment> > UpdatePayment(UpdatePayment request)
{
PaymentMapper mapPayment = new PaymentMapper();
try
{
string readJsonString = File.ReadAllText("Payments/Data/payments.json");
var paymentList = JsonSerializer.Deserialize <IEnumerable <Payment> >(readJsonString);
GC.Collect();
GC.WaitForPendingFinalizers();
var paymentValues = mapPayment.MapPaymentsForUpdate(paymentList);
foreach (var item in paymentValues.Where(data => data.Id == request.Id))
{
item.Status = "Paid";
}
string jsonString = JsonSerializer.Serialize(paymentValues, new JsonSerializerOptions {
PropertyNamingPolicy = JsonNamingPolicy.CamelCase
});
File.WriteAllText("Payments/Data/payments.json", jsonString);
return(await JsonSerializer
.DeserializeAsync <IEnumerable <Payment> >(File.OpenRead("Payments/Data/payments.json")));
}
catch (System.Exception ex)
{
throw ex;
}
finally
{
GC.Collect();
GC.WaitForPendingFinalizers();
}
}
public IActionResult Finalize(OrderModel order)
{
DBContext _context = new DBContext();
AddressModel address = order.Address;
_context.Update(AddressMapper.Mapper(address));
PaymentModel payment = order.Payment;
if (order.Payment.Method == Models.Enums.PaymentMethodEnum.Pix || order.Payment.Method == Models.Enums.PaymentMethodEnum.BankSlip)
{
payment.Status = Models.Enums.PaymentStatusEnum.Pending;
}
if (order.Payment.Method == Models.Enums.PaymentMethodEnum.CreditCard)
{
payment.Status = Models.Enums.PaymentStatusEnum.Pay;
}
_context.Update(PaymentMapper.Mapper(payment));
_context.SaveChanges();
return(View("Finalize", order));
}
public PaymentCrud()
{
Mapper = new PaymentMapper();
Dao = SqlDao.GetInstance();
}
public static bool Payment(Order order)
{
return(PaymentMapper.insertOrder(order) > 0);
}
public override async Task <BLL.App.DTO.Payment> FindAsync(params object[] id)
{
return(PaymentMapper.MapFromDAL(await Uow.Payments.FindAsync(id)));
}
public PaymentService(IPaymentRepository repos)
{
Repository = repos;
PaymentMapper.Map();
}
public PaymentCrudFactory() : base()
{
mapper = new PaymentMapper();
dao = SqlDao.GetInstance();
}
internal static bool CompletePayment(Order order)
{
return(PaymentMapper.insertCompletePayment(order) > 0);
}
internal static Order Order(string order, int UsertID)
{
return(PaymentMapper.GetOrder(order, UsertID));
}
public IActionResult Carregar()
{
var buyer = this.User.FindFirstValue(ClaimTypes.NameIdentifier);
DBContext _context = new DBContext();
OrderModel validacao = OrderMapper.Mapper(_context.Order.Include(x => x.Address).Include(x => x.Buyer).Include(x => x.Seller).Where(x => x.BuyerId == Guid.Parse(buyer)).FirstOrDefault());
if (validacao == null)
{
ProductModel p1 = new ProductModel
{
Id = Guid.NewGuid(),
Code = "0001",
Name = "Coca-Cola",
Description = "Refrigerante",
ImageUrl = "https://i.imgur.com/ps6alt2.jpg",
Skus = new List <SkuModel>()
};
SkuModel s1 = new SkuModel
{
Id = Guid.NewGuid(),
Barcode = "793001215",
Name = "350 ml",
Color = "#ff0000",
Price = 4.50
};
SkuModel s2 = new SkuModel
{
Id = Guid.NewGuid(),
Barcode = "793001216",
Name = "2 L",
Color = "#ff0000",
ImageUrl = "https://i.imgur.com/ps6alt2.jpg",
Price = 7.00
};
p1.Skus.Add(s1);
p1.Skus.Add(s2);
_context.Products.Add(ProductMapper.Mapper(p1));
ProductModel p2 = new ProductModel
{
Id = Guid.NewGuid(),
Name = "Fanta Laranja",
Code = "0002",
Description = "Refri de laranja",
ImageUrl = "https://i.imgur.com/cxKXQ0k.png",
Skus = new List <SkuModel>()
};
SkuModel s3 = new SkuModel
{
Id = Guid.NewGuid(),
Name = "350 ml",
Barcode = "79300251362",
Price = 4.50,
Color = "#f24f00",
ImageUrl = "https://i.imgur.com/cxKXQ0k.png"
};
p2.Skus.Add(s3);
_context.Products.Add(ProductMapper.Mapper(p2));
UserModel u = new UserModel
{
Id = Guid.NewGuid(),
FullName = "Shopping Palladium",
Document = "08355847000109",
Discriminator = Models.Enums.DiscriminatorEnum.Seller
};
_context.Users.Add(UserMapper.Mapper(u));
SkuStocksModel ss = new SkuStocksModel
{
Id = Guid.NewGuid(),
AvailableQuantity = 52,
LastUpdate = DateTime.Now,
Sku = s2,
Seller = u
};
SkuStocksModel ss2 = new SkuStocksModel
{
Id = Guid.NewGuid(),
AvailableQuantity = 31,
LastUpdate = DateTime.Now,
Sku = s3,
Seller = u
};
_context.Stocks.Add(StockMapper.Mapper(ss));
_context.Stocks.Add(StockMapper.Mapper(ss2));
ShowcaseModel sc = new ShowcaseModel
{
Id = Guid.NewGuid(),
Name = "Inverno",
StartDate = DateTime.Now,
EndDate = DateTime.Now,
LastUpdate = DateTime.Now
};
ShowcaseItemsModel scp1 = new ShowcaseItemsModel()
{
Id = Guid.NewGuid(),
ShowCase = sc,
Sku = s2
};
ShowcaseItemsModel scp2 = new ShowcaseItemsModel()
{
Id = Guid.NewGuid(),
ShowCase = sc,
Sku = s3
};
ShowcaseItemsMapper.Mapper(scp1);
ShowcaseItemsMapper.Mapper(scp2);
_context.Showcases.Add(ShowcaseMapper.Mapper(sc));
_context.ShowcaseItems.Add(ShowcaseItemsMapper.Mapper(scp1));
_context.ShowcaseItems.Add(ShowcaseItemsMapper.Mapper(scp2));
AddressModel address = new AddressModel
{
Id = Guid.NewGuid()
};
_context.Add(AddressMapper.Mapper(address));
PaymentModel payment = new PaymentModel
{
Id = Guid.NewGuid()
};
_context.Add(PaymentMapper.Mapper(payment));
OrderModel order = new OrderModel
{
Id = Guid.NewGuid(),
CreateDate = DateTime.Now,
Discount = 0,
SubTotal = 0,
Total = 0,
FriendlyCode = "S&T-X3VI5A",
Buyer = new UserModel
{
Id = Guid.Parse(this.User.FindFirstValue(ClaimTypes.NameIdentifier)),
},
Seller = new UserModel
{
Id = u.Id,
},
Address = address,
Payment = payment
};
_context.Order.Add(OrderMapper.Mapper(order));
_context.SaveChanges();
}
return(RedirectToAction("Index"));
}
public async Task <Payment> FindForUserAsync(int id, int userId)
{
return(PaymentMapper.MapFromDAL(await Uow.Payments.FindForUserAsync(id, userId)));
}
