public JsonResult SetPaymentMethods(PaymentInputModel inputModel)
{
try
{
Assert.ArgumentNotNull(inputModel, nameof(inputModel));
var validationResult = this.CreateJsonResult();
if (validationResult.HasErrors)
{
return(Json(validationResult, JsonRequestBehavior.AllowGet));
}
var response = CartManager.SetPaymentMethods(CommerceUserContext.Current.UserId, inputModel);
var result = new CartApiModel(response.ServiceProviderResult);
if (!response.ServiceProviderResult.Success || response.Result == null)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
result.Initialize(response.Result);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new ErrorApiModel("SetPaymentMethods", e), JsonRequestBehavior.AllowGet));
}
}
public JsonResult SetPaymentMethods(PaymentInputModel inputModel)
{
try
{
Assert.ArgumentNotNull(inputModel, nameof(inputModel));
var validationResult = this.CreateJsonResult();
if (validationResult.HasErrors)
{
return(Json(validationResult, JsonRequestBehavior.AllowGet));
}
var response = this.GetCart();
var result = new CartApiModel();
result.Initialize(response);
var paymentServiceResponse = this.PaymentManager.GetPaymentServiceActionResult(inputModel.FederatedPayment.CardToken);
if (paymentServiceResponse.ServiceProviderResult.Success = false || string.IsNullOrEmpty(paymentServiceResponse.Result))
{
result.SetErrors(new List <string> {
"CardAuthorizationFailed"
});
result.SetErrors(paymentServiceResponse.ServiceProviderResult);
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
return(Json(new ErrorApiModel("SetPaymentMethods", e), JsonRequestBehavior.AllowGet));
}
}
public async Task AddAsync(PaymentInputModel paymentInputModel)
{
var payment = new Payment
{
ElevatorSubscription = paymentInputModel.ElevatorSubscription,
ElevatorElectricity = paymentInputModel.ElevatorElectricity,
StairElectricity = paymentInputModel.StairElectricity,
CleaningService = paymentInputModel.CleaningService,
RunningCosts = paymentInputModel.RunningCosts,
RepairAndRestorationFund = paymentInputModel.RepairAndRestorationFund,
HouseManagerFee = paymentInputModel.HouseManagerFee,
TotalSum = paymentInputModel.TotalSum,
ApartmentId = paymentInputModel.ApartmentId,
};
bool doesPaymentExist = await this.paymentsRepository.All().AnyAsync(x => x.Id == payment.Id);
if (doesPaymentExist)
{
throw new ArgumentException(string.Format(GlobalConstants.ErrorMessages.PaymentExists, payment.Id));
}
payment.IsItPaid = false;
await this.paymentsRepository.AddAsync(payment);
await this.paymentsRepository.SaveChangesAsync();
}
public JsonResult SetPaymentMethods(PaymentInputModel inputModel)
{
try
{
Assert.ArgumentNotNull(inputModel, "inputModel");
var validationResult = new BaseJsonResult();
this.ValidateModel(validationResult);
if (validationResult.HasErrors)
{
return(Json(validationResult, JsonRequestBehavior.AllowGet));
}
var response = this.CartManager.SetPaymentMethods(this.CurrentStorefront, this.CurrentVisitorContext, inputModel);
var result = new CSCartBaseJsonResult(response.ServiceProviderResult);
if (!response.ServiceProviderResult.Success || response.Result == null)
{
return(Json(result, JsonRequestBehavior.AllowGet));
}
result.Initialize(response.Result);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
CommerceLog.Current.Error("SetPaymentMethods", this, e);
return(Json(new BaseJsonResult("SetPaymentMethods", e), JsonRequestBehavior.AllowGet));
}
}
public IActionResult AddPayment(int id)
{
var model = new PaymentInputModel()
{
OrderId = id
};
return(this.View(model));
}
public IActionResult LogTransaction([FromBody] PaymentInputModel payment)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
return(Ok(_paymentAppService.MakePayment(payment)));
}
public async Task AddPartialPaymentShouldAddPaymentAndUpdateStatus()
{
var options = new DbContextOptionsBuilder <WHMSDbContext>().UseInMemoryDatabase(databaseName: Guid.NewGuid().ToString()).Options;
using var context = new WHMSDbContext(options);
var warehouse = new Warehouse
{
Address = new Address {
},
Name = "Test",
};
var product = new Product
{
ProductName = "Test Product",
};
var productWarehouse = new ProductWarehouse
{
Product = product,
Warehouse = warehouse,
AggregateQuantity = 0,
TotalPhysicalQuanitiy = 10,
ReservedQuantity = 5,
};
context.Warehouses.Add(warehouse);
context.Products.Add(product);
context.ProductWarehouses.Add(productWarehouse);
var order = new Order {
WarehouseId = warehouse.Id, GrandTotal = 100
};
context.Orders.Add(order);
var orderItem = new OrderItem {
OrderId = order.Id, ProductId = product.Id, Qty = 3
};
context.Orders.Add(order);
context.OrderItems.Add(orderItem);
await context.SaveChangesAsync();
var mockInventoryService = new Mock <IInventoryService>();
var mockCustomersService = new Mock <ICustomersService>();
var service = new OrdersService(context, mockInventoryService.Object, mockCustomersService.Object);
var payment = new PaymentInputModel {
OrderId = order.Id, Amount = 50
};
await service.AddPaymentAsync(payment);
var paymentDb = context.Payments.FirstOrDefault();
Assert.NotNull(paymentDb);
Assert.True(order.PaymentStatus == PaymentStatus.PartiallyPaid);
Assert.Equal(50, paymentDb.Amount);
}
public async Task <IActionResult> AddPayment(PaymentInputModel input)
{
if (!this.ModelState.IsValid)
{
return(this.View(input));
}
await this.ordersService.AddPaymentAsync(input);
return(this.RedirectToAction(nameof(this.OrderDetails), new { id = input.OrderId }));
}
public CSCartBaseJsonResult SetPaymentMethods(PaymentInputModel inputModel)
{
var response = this._cartManager.SetPaymentMethods(this.CurrentStorefront, this.CurrentVisitorContext, inputModel);
var result = new CSCartBaseJsonResult(response.ServiceProviderResult);
if (response.ServiceProviderResult.Success && response.Result != null)
{
result.Initialize(response.Result, _productResolver);
}
return(result);
}
public async Task <IActionResult> Create()
{
var user = await this.userManager.GetUserAsync(this.User);
var userNames = user.FirstName + ' ' + user.LastName;
var customerService = new CustomerService();
var customers = await customerService.ListAsync();
var customer = customers.FirstOrDefault(x => x.Name == userNames);
if (customer == null)
{
var customerOptions = new CustomerCreateOptions
{
Name = userNames,
Email = user.Email,
Phone = user.PhoneNumber,
Metadata = new Dictionary <string, string>
{
["HotelId"] = user.HotelId.ToString(),
["UserId"] = user.Id,
["BirthDate"] = user.BirthDate.ToShortDateString(),
["Username"] = user.UserName,
},
};
customer = await customerService.CreateAsync(customerOptions);
}
var priceService = new PriceService();
var price = await priceService.GetAsync("price_1IP1xzLxakYJAQmTh3ple3eB");
var service = new PaymentIntentService();
var options = new PaymentIntentCreateOptions
{
Amount = price.UnitAmount,
Currency = "bgn",
SetupFutureUsage = "on_session",
Customer = customer.Id,
};
var paymentIntent = await service.CreateAsync(options);
var model = new PaymentInputModel
{
Token = paymentIntent.ClientSecret,
PaymentId = paymentIntent.Id,
StripePublishableKey = this.configuration["Stripe:PublishableKey"],
};
return(this.View(model));
}
public async Task <bool> Add(PaymentInputModel paymentInputModel)
{
var donation = await _donationRepository.Add(new Donation(paymentInputModel.DonatedAmount,
"OK",
paymentInputModel.AnonymousDonation,
"INTEGRACAO",
paymentInputModel.PersonId));
if (donation > 0)
{
await _supporterRepository.Add(new Supporter(paymentInputModel.OngId, donation));
}
return(donation > 0);
}
public IActionResult Add(PaymentInputModel input)
{
if (!ModelState.IsValid)
{
return(View(input));
}
var payment = _mapper.Map <Payment>(input);
_paymentService.AddPayment(payment);
_paymentService.SaveChanges();
_logger.LogInformation("{user} added payment {payment}", User.Identity.Name, payment.Id);
return(RedirectToAction("Index"));
}
public async Task <IActionResult> Post([FromBody] PaymentInputModel paymentInputModel)
{
bool ret;
var personId = GetPersonId();
if (!personId.HasValue)
{
return(NotFound());
}
paymentInputModel.PersonId = (int)personId;
ret = await _paymentService.Add(paymentInputModel);
return(Ok(new { Ok = ret }));
}
public async Task <IActionResult> AddPayment(PaymentInputModel paymentInputModel)
{
if (!this.ModelState.IsValid)
{
return(this.View(paymentInputModel));
}
try
{
await this.paymentsService.AddAsync(paymentInputModel);
}
catch (Exception)
{
return(this.View("DuplicateValue", paymentInputModel));
}
return(this.RedirectToAction("Index"));
}
private async Task <Charge> MakePayment2(PaymentInputModel payModel)
{
try
{
StripeConfiguration.ApiKey = this.SecretKey;; // "pk_test_51HiQuVAFZv6rpRFk3K1JeutsplKLBU7nFnti3wi6xZ6YW7sHUPJl433JQF4K9kSO0VsxX3edkIgrJrrbdzFPSGdt00a6LlFJ7W";
var optionsToken = new TokenCreateOptions
{
Card = new TokenCardOptions
{
Number = payModel.cardNumber,
ExpMonth = payModel.month,
ExpYear = payModel.year,
Cvc = payModel.cvc
},
};
var serviceToken = new Stripe.TokenService();
Token stripeToken = await serviceToken.CreateAsync(optionsToken);
var options = new ChargeCreateOptions
{
Amount = GetFormattedAmount((long)payModel.value),
Currency = "USD",
Description = $"Payment taken by Moo-In at {payModel.RestaurantName}",
Source = stripeToken.Id,
Metadata = new Dictionary <string, string>
{
{ "OrderId", payModel.Order.rec_id.ToString() },
},
ApplicationFeeAmount = GetShareAmount(payModel.value)
};
var service = new ChargeService();
Charge charge = await service.CreateAsync(options, new RequestOptions { StripeAccount = payModel.StripeAccountId });
return(charge);
}
catch (Exception e)
{
throw;
}
}
/// <summary>
/// Make Payment
/// </summary>
/// <param name="payment"></param>
/// <returns></returns>
public ResponseViewModel MakePayment(PaymentInputModel payment)
{
var subscription = _subscriptionAppService.GetSubscriptions().FirstOrDefault(x => x.SubscriptionId == payment.SubscriptionId);
//TODO: Please do try and catch inside Business Logic instead of the following you, SMH
if (subscription == null)
{
return(Failed(ResponseMessageViewModel.INVALID_SUBSCRIPTION_ENTRY, ResponseErrorCodeStatus.INVALID_SUBSCRIPTION_ENTRY));
}
var types = _paymentService.GetAllPaymentTypes().FirstOrDefault(x => x.Id == payment.PaymentTypeId);
if (types == null)
{
return(Failed(ResponseMessageViewModel.INVALID_PAYMENT_TYPE, ResponseErrorCodeStatus.INVALID_PAYMENT_TYPE));
}
var methods = _paymentService.GetAllPaymentMethods().FirstOrDefault(x => x.Id == payment.PaymentMethodId);
if (methods == null)
{
return(Failed(ResponseMessageViewModel.INVALID_PAYMENT_METHOD, ResponseErrorCodeStatus.INVALID_PAYMENT_METHOD));
}
var providers = _paymentService.GetAllPaymentProviders().FirstOrDefault(x => x.Id == payment.PaymentProviderId);
if (providers == null)
{
return(Failed(ResponseMessageViewModel.INVALID_PAYMENT_PROVIDER, ResponseErrorCodeStatus.INVALID_PAYMENT_PROVIDER));
}
var result = _paymentService.LogNewPayment(payment.SubscriptionId, payment.PaymentTypeId, payment.PaymentMethodId, payment.PaymentProviderId, 0);
var mappedResult = _mapper.Map <Payment, PaymentViewModel>(result);
return(Ok(mappedResult));
}
public JsonResult SetPaymentMethods(PaymentInputModel inputModel)
{
try
{
Assert.ArgumentNotNull(inputModel, "inputModel");
var validationResult = new BaseJsonResult();
this.ValidateModel(validationResult);
if (validationResult.HasErrors)
{
return(Json(validationResult, JsonRequestBehavior.AllowGet));
}
var result = _checkoutRepository.SetPaymentMethods(inputModel);
return(Json(result, JsonRequestBehavior.AllowGet));
}
catch (Exception e)
{
_logger.LogError("SetPaymentMethods", this, e);
return(Json(new BaseJsonResult("SetPaymentMethods", e), JsonRequestBehavior.AllowGet));
}
}
public ManagerResponse <CartResult, CommerceCart> SetPaymentMethods(CommerceStorefront storefront, IVisitorContext visitorContext, PaymentInputModel inputModel)
{
return(null);
}
/// <summary>
/// Sets the payment methods.
/// </summary>
/// <param name="storefront">The storefront.</param>
/// <param name="visitorContext">The visitor context.</param>
/// <param name="inputModel">The input model.</param>
/// <returns>The manager response with a cart in the result.</returns>
public virtual ManagerResponse <CartResult, CommerceCart> SetPaymentMethods([NotNull] CommerceStorefront storefront, [NotNull] VisitorContext visitorContext, [NotNull] PaymentInputModel inputModel)
{
Assert.ArgumentNotNull(storefront, "storefront");
Assert.ArgumentNotNull(visitorContext, "visitorContext");
Assert.ArgumentNotNull(inputModel, "inputModel");
var result = new AddPaymentInfoResult {
Success = false
};
var response = this.GetCurrentCart(storefront, visitorContext, true);
if (!response.ServiceProviderResult.Success || response.Result == null)
{
return(new ManagerResponse <CartResult, CommerceCart>(result, response.Result));
}
var payments = new List <PaymentInfo>();
var cart = (CommerceCart)response.ServiceProviderResult.Cart;
if (inputModel.CreditCardPayment != null && !string.IsNullOrEmpty(inputModel.CreditCardPayment.PaymentMethodID) && inputModel.BillingAddress != null)
{
CommerceParty billingParty = inputModel.BillingAddress.ToParty();
List <Party> parties = cart.Parties.ToList();
parties.Add(billingParty);
cart.Parties = parties.AsSafeReadOnly();
payments.Add(inputModel.CreditCardPayment.ToCreditCardPaymentInfo());
}
if (inputModel.FederatedPayment != null && !string.IsNullOrEmpty(inputModel.FederatedPayment.CardToken) && inputModel.BillingAddress != null)
{
CommerceParty billingParty = inputModel.BillingAddress.ToParty();
List <Party> parties = cart.Parties.ToList();
parties.Add(billingParty);
cart.Parties = parties.AsSafeReadOnly();
var federatedPayment = inputModel.FederatedPayment.ToCreditCardPaymentInfo();
federatedPayment.PartyID = billingParty.PartyId;
payments.Add(federatedPayment);
}
if (inputModel.GiftCardPayment != null && !string.IsNullOrEmpty(inputModel.GiftCardPayment.PaymentMethodID))
{
payments.Add(inputModel.GiftCardPayment.ToGiftCardPaymentInfo());
}
if (inputModel.LoyaltyCardPayment != null && !string.IsNullOrEmpty(inputModel.LoyaltyCardPayment.PaymentMethodID))
{
payments.Add(inputModel.LoyaltyCardPayment.ToLoyaltyCardPaymentInfo());
}
var request = new AddPaymentInfoRequest(cart, payments);
result = this.CartServiceProvider.AddPaymentInfo(request);
if (!result.Success)
{
Helpers.LogSystemMessages(result.SystemMessages, result);
}
return(new ManagerResponse <CartResult, CommerceCart>(result, result.Cart as CommerceCart));
}
public ManagerResponse <CartResult, CommerceCart> SetPaymentMethods(string userId, PaymentInputModel inputModel)
{
Assert.ArgumentNotNull(inputModel, nameof(inputModel));
var result = new AddPaymentInfoResult {
Success = false
};
var response = GetCart(userId, true);
if (!response.ServiceProviderResult.Success || response.Result == null)
{
return(new ManagerResponse <CartResult, CommerceCart>(result, response.Result));
}
var payments = new List <PaymentInfo>();
var cart = (CommerceCart)response.ServiceProviderResult.Cart;
if (!string.IsNullOrEmpty(inputModel.CreditCardPayment?.PaymentMethodID) && inputModel.BillingAddress != null)
{
var billingParty = inputModel.BillingAddress.ToParty();
var parties = cart.Parties.ToList();
parties.Add(billingParty);
cart.Parties = parties.AsSafeReadOnly();
payments.Add(inputModel.CreditCardPayment.ToCreditCardPaymentInfo());
}
if (!string.IsNullOrEmpty(inputModel.FederatedPayment?.CardToken) && inputModel.BillingAddress != null)
{
var billingParty = inputModel.BillingAddress.ToParty();
var parties = cart.Parties.ToList();
parties.Add(billingParty);
cart.Parties = parties.AsSafeReadOnly();
var federatedPayment = inputModel.FederatedPayment.ToFederatedPaymentInfo();
federatedPayment.PartyID = billingParty.PartyId;
payments.Add(federatedPayment);
}
if (!string.IsNullOrEmpty(inputModel.GiftCardPayment?.PaymentMethodID))
{
payments.Add(inputModel.GiftCardPayment.ToGiftCardPaymentInfo());
}
var request = new AddPaymentInfoRequest(cart, payments);
result = CartServiceProvider.AddPaymentInfo(request);
result.WriteToSitecoreLog();
return(new ManagerResponse <CartResult, CommerceCart>(result, result.Cart as CommerceCart));
}
