public async Task <IActionResult> SelectPlan(PlanSelectModel model, string returnUrl)
{
model.PlanTypeOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.PlanType));
model.PlanPeriodOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.PlanPeriod));
if (HttpMethods.IsGet(Request.Method))
{
ModelState.Clear();
}
else if (HttpMethods.IsPost(Request.Method))
{
if (ModelState.IsValid)
{
var member = await HttpContext.GetMemberAsync();
returnUrl = XQueryHelpers.RemoveQueryString(returnUrl, "modalUrl") ?? Url.Content("~/");
returnUrl = Url.IsLocalUrl(returnUrl) ? returnUrl : throw new InvalidOperationException("The supplied URL is not local.");
ViewData["Redirect"] = QueryHelpers.AddQueryString(returnUrl, "modalUrl",
Url.Action(nameof(CashIn), new
{
reference = member.UserCode,
type = TransactionType.Subscription,
planType = model.PlanType,
planPeriod = model.PlanPeriod,
returnUrl = Url.Action("Index", "Home", new { area = "Portal" })
}));
}
}
return(PartialView(model));
}
public Task PrepareModelAsync(TransactionListModel model, IPageable <Transaction> transactions)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (transactions == null)
{
throw new ArgumentNullException(nameof(transactions));
}
foreach (var transaction in transactions)
{
var transactionModel = new TransactionModel
{
Transaction = transaction
};
model.Items.Add(transactionModel);
}
model.ModeOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Mode, defaultText: "All"));
model.StatusOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Status, defaultText: "All"));
model.ProcessorOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Processor, defaultText: "All"));
model.TypeOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Type, defaultText: "All"));
model.Page = transactions.Page;
model.PageSize = transactions.PageSize;
model.PageFrom = transactions.PageFrom;
model.PageTo = transactions.PageTo;
model.TotalPages = transactions.TotalPages;
model.TotalItems = transactions.TotalItems;
return(Task.CompletedTask);
}
public async Task PrepareModelAsync(OrderListModel model, IPageable <Order> orders)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (orders == null)
{
throw new ArgumentNullException(nameof(orders));
}
foreach (var order in orders)
{
var orderModel = new OrderModel();
await PrepareModelAsync(orderModel, order);
model.Items.Add(orderModel);
}
model.StatusOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Status, defaultText: "All"));
model.Page = orders.Page;
model.PageSize = orders.PageSize;
model.PageFrom = orders.PageFrom;
model.PageTo = orders.PageTo;
model.TotalPages = orders.TotalPages;
model.TotalItems = orders.TotalItems;
}
public async Task PrepareModelAsync(ProductEditModel model, Product product, User seller)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (seller == null)
{
throw new ArgumentNullException(nameof(seller));
}
if (product != null)
{
model = _mapper.Map(product, model);
model.Images = product.Images.ToList();
model.TagNames.AddRange(product.Tags.Select(x => x.Name));
}
else
{
model.Published = true;
model.Stock = ProductStock.InStock;
}
model.StockOptions.AddRange(SelectListHelper.GetEnumSelectList <ProductStock>(selectedEnum: model.Stock));
var categoryNames = (await _categoryService.ListAsync(new CategoryFilter {
SellerId = seller.Id
})).Select(x => x.Name).Distinct();
var tagNames = (await _tagService.ListAsync(new TagFilter {
SellerId = seller.Id
})).Select(x => x.Name).Distinct();
tagNames = categoryNames.Concat(tagNames).Distinct(StringComparer.InvariantCultureIgnoreCase);
model.TagOptions.AddRange(SelectListHelper.GetSelectList(tagNames, x => new SelectListItem <string>(text: x, value: x)));
}
public Task PrepareModelAsync(BannerListModel model, IPageable <Banner> banners)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (banners == null)
{
throw new ArgumentNullException(nameof(banners));
}
foreach (var banner in banners)
{
var bannerModel = new BannerModel
{
Banner = banner
};
model.Items.Add(bannerModel);
}
var imageSize = model.Filter.Size.GetValueOrDefault();
var imageSizeInfo = AttributeHelper.GetMemberAttribute <ImageSizeAttribute>(typeof(BannerSize).GetMember(imageSize.ToString())[0]);
model.ImageWidth += imageSizeInfo.Width;
model.ImageHeight += imageSizeInfo.Height;
model.SizeOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Size, defaultText: "All"));
model.Page = banners.Page;
model.PageSize = banners.PageSize;
model.PageFrom = banners.PageFrom;
model.PageTo = banners.PageTo;
model.TotalPages = banners.TotalPages;
model.TotalItems = banners.TotalItems;
return(Task.CompletedTask);
}
public Task PrepareModelAsync(StoreEditModel model, User user)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
model = _mapper.Map(user, model);
model.StoreDeliveryRequiredOptions.AddRange(SelectListHelper.GetBoolSelectList("Required", "Not Required", selectedBool: model.StoreDeliveryRequired));
model.StoreStatusOptions.AddRange(SelectListHelper.GetEnumSelectList <StoreStatus>(selectedEnum: model.StoreStatus));
model.StoreThemeModeOptions.AddRange(SelectListHelper.GetEnumSelectList <ThemeMode>(selectedEnum: model.StoreThemeMode));
model.StoreThemeStyleOptions.AddRange(SelectListHelper.GetEnumSelectList <ThemeStyle>(selectedEnum: model.StoreThemeStyle));
model.StoreCategorySelections.AddRange(user.StoreCategory.ExpandEnum());
model.StoreCategoryOptions.AddRange(SelectListHelper.GetEnumSelectList <StoreCategory>(selectedEnum: user.StoreCategory));
return(Task.CompletedTask);
}
public async Task PrepareModelAsync(UserListModel model, IPageable <User> users, Func <UserModel, User, Task> prepareChildModel = null)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (users == null)
{
throw new ArgumentNullException(nameof(users));
}
foreach (var user in users)
{
var userModel = new UserModel
{
User = user
};
if (prepareChildModel != null)
{
await prepareChildModel(userModel, user);
}
model.Items.Add(userModel);
}
model.StoreCategoryOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.StoreCategory, defaultText: "All"));
model.StoreSetupOptions.AddRange(SelectListHelper.GetBoolSelectList("Completed", "Not Completed", selectedBool: model.Filter.StoreSetup, defaultText: "Any"));
model.Page = users.Page;
model.PageSize = users.PageSize;
model.PageFrom = users.PageFrom;
model.PageTo = users.PageTo;
model.TotalPages = users.TotalPages;
model.TotalItems = users.TotalItems;
}
public async Task <IActionResult> CashIn(CashInModel model, string returnUrl)
{
var processors = EnumHelper.GetEnumValues <TransactionProcessor>().ToList();
if (model.Type == TransactionType.Deposit ||
model.Type == TransactionType.Withdrawal ||
model.Type == TransactionType.Subscription)
{
processors.Remove(TransactionProcessor.Internal);
model.ProcessorHide = true;
}
model.ProcessorOptions.AddRange(SelectListHelper.GetEnumSelectList(
enums: processors, getText: x =>
{
if (x == TransactionProcessor.Internal)
{
return("Pay with Wallet");
}
else if (x == TransactionProcessor.External)
{
return($"Pay with Card/MoMo");
}
else
{
throw new InvalidOperationException();
}
}, selectedEnum: model.Processor));
var transactionReferenceObject = default(object);
var transactionDataList = new Dictionary <string, object>();
var transactionMemberId = default(long);
var transactionAccountBalance = default(decimal);
var transactionAccountName = default(string);
var transactionAccountEmail = default(string);
var transactionAccountNumber = default(string);
if (model.Type == TransactionType.Subscription)
{
var member = await _userService.FindByCodeAsync(model.Reference);
var requestQuery = Request.Query.ToDictionary(x => x.Key, x => x.Value.ToString() as object);
var planType = requestQuery.ValueOrDefault <PlanType>("planType");
var planPeriod = requestQuery.ValueOrDefault <PlanPeriod>("planPeriod");
var planRate = _appSettings.PlanRates.ElementAt((int)planType);
var planAmount = planRate * (int)planPeriod;
var paymentFee = model.Processor == TransactionProcessor.External ? Math.Round(((_appSettings.PaymentRate * 100) * planAmount) / 100, 2, MidpointRounding.AwayFromZero) : 0;
model.Amount = planAmount;
model.Fee = paymentFee;
transactionMemberId = member.Id;
transactionAccountName = member.FullName;
transactionAccountEmail = member.Email;
transactionAccountNumber = member.PhoneNumber;
transactionAccountBalance = member.Balance;
transactionDataList.Add("PlanType", planType);
transactionDataList.Add("PlanPeriod", planPeriod);
transactionReferenceObject = member;
}
else if (model.Type == TransactionType.Order)
{
var order = await _orderService.GetAsync(new OrderFilter { OrderCode = model.Reference ?? string.Empty });
var orderAmount = order.TotalAmount;
var paymentFee = model.Processor == TransactionProcessor.External ? Math.Round(((_appSettings.PaymentRate * 100) * orderAmount) / 100, 2, MidpointRounding.AwayFromZero) : 0;
model.Amount = orderAmount;
model.Fee = paymentFee;
transactionMemberId = order.Customer.Id;
transactionAccountName = order.Customer.FullName;
transactionAccountEmail = order.Customer.Email;
transactionAccountNumber = order.Customer.PhoneNumber;
transactionAccountBalance = order.Customer.Balance;
transactionReferenceObject = order;
}
else if (model.Type == TransactionType.Deposit)
{
var member = await _userService.FindByCodeAsync(model.Reference);
var depositAmount = model.Amount;
var paymentFee = model.Processor == TransactionProcessor.External ? Math.Round(((_appSettings.PaymentRate * 100) * depositAmount) / 100, 2, MidpointRounding.AwayFromZero) : 0;
model.Amount = depositAmount;
model.Fee = paymentFee;
transactionMemberId = member.Id;
transactionAccountName = member.FullName;
transactionAccountEmail = member.Email;
transactionAccountNumber = member.PhoneNumber;
transactionAccountBalance = member.Balance;
transactionReferenceObject = member;
}
if (HttpMethods.IsGet(Request.Method))
{
ModelState.Clear();
}
else
{
if (ModelState.IsValid)
{
var transaction = new Transaction
{
Reference = model.Reference,
Type = model.Type,
Processor = model.Processor,
Amount = model.Amount,
Fee = model.Fee,
Title = $"Payment for {model.Type.GetEnumText()}.",
Description = $"Payment for {model.Type.GetEnumText()}.",
Logo = Url.ContentLink(Url.Content("~/img/logo.png")),
MemberId = transactionMemberId,
AccountName = transactionAccountName,
AccountEmail = transactionAccountEmail,
AccountNumber = transactionAccountNumber,
AccountBalance = transactionAccountBalance,
TransactionCode = await _paymentProcessor.GenerateTransactionCodeAsync(),
AuthorizationCode = await _paymentProcessor.GetAuthorizationCodeAsync(),
IpAddress = await HttpContext.GetIpAddressAsync(),
UserAgent = Request.Headers["User-Agent"],
RedirectUrl = Url.ContentLink(returnUrl),
CallbackUrl = Url.ContentLink(Url.Action(nameof(CashInCallback), "Account")),
};
foreach (var transactionData in transactionDataList)
{
transaction.SetValue(transactionData.Key, transactionData.Value);
}
if (transaction.Type == TransactionType.Order)
{
var order = (Order)transactionReferenceObject;
if (order.Status == OrderStatus.Cancelled || order.Paid)
{
ModelState.AddModelError(string.Empty, "The order may have been paid, cancelled or deleted.");
return(PartialView(model));
}
}
if (transaction.Processor == TransactionProcessor.Internal && transaction.Type == TransactionType.Order)
{
var order = (Order)transactionReferenceObject;
var transfer = await _userService.TransferAsync(order.Customer, order.Seller, transaction.Amount);
if (transfer.Success)
{
transaction.Status = TransactionStatus.Succeeded;
transaction.Issuer = "USE";
transaction.Mode = PaymentMode.Virtual;
await _transactionService.CreateAsync(transaction);
// TODO: Repetition, This code has properly been repeated elsewhere. Take note!
var orderStatus = order.Seller.StoreDeliveryRequired ?
EnumHelper.GetEnumValues <OrderStatus>().NextOrDefault(order.Status, OrderStatus.Complete) : OrderStatus.Complete;
order.Status = orderStatus;
order.Paid = true;
order.PaidOn = DateTimeOffset.UtcNow;
await _orderService.UpdateAsync(order);
await _userService.DepositAsync(order.Seller, transaction.Amount);
// Prepare order model
var orderModel = new OrderModel();
await _appService.PrepareModelAsync(orderModel, order);
// Send order placed email to the seller.
await _messageService.SendStoreOrderEmailAsync(orderModel);
// Send order status email to the customer.
await _messageService.SendCustomerOrderEmailAsync(orderModel);
TempData.AddAlert(AlertMode.Notify, AlertType.Success, "Payment successful!");
ViewData["Redirect"] = returnUrl;
}
else
{
ModelState.AddModelError(string.Empty, transfer.Message);
}
}
else
{
await _paymentProcessor.ProcessAsync(transaction);
if (transaction.Status == TransactionStatus.Pending)
{
await _transactionService.CreateAsync(transaction);
ViewData["Redirect"] = transaction.CheckoutUrl;
}
else
{
ModelState.AddModelError(string.Empty, "Unable to process payment.");
}
}
}
}
return(PartialView(model));
}
public async Task PrepareModelAsync(ProductListModel model, IPageable <Product> products, User seller, User customer = null)
{
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
if (products == null)
{
throw new ArgumentNullException(nameof(products));
}
foreach (var product in products)
{
var productModel = new ProductModel();
await PrepareModelAsync(productModel, product);
if (customer != null)
{
productModel.IsAddedToCart = await _cartService.GetQuery(new CartFilter { CustomerId = customer.Id, SellerId = seller.Id, ProductId = product.Id, Type = CartType.Cart }).AnyAsync();
productModel.IsAddedToWishlist = await _cartService.GetQuery(new CartFilter { CustomerId = customer.Id, SellerId = seller.Id, ProductId = product.Id, Type = CartType.Wishlist }).AnyAsync();
}
// NOTE: "StoreController.cs" with the line number 299 for code changes.
productModel.ReviewEvaluation = await _reviewService.EvaluateAsync(new ReviewFilter
{
Approved = true,
SellerId = seller.Id,
ProductId = product.Id
});
model.Items.Add(productModel);
}
model.LowestMinPrice = 0;
model.HighestMaxPrice = (int)Math.Min(_appSettings.CurrencyMaxValue, int.MaxValue);
model.SortOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Sort, defaultText: "Any"));
model.StockOptions.AddRange(SelectListHelper.GetEnumSelectList(selectedEnum: model.Filter.Stock, defaultText: "All"));
model.PublishedOptions.AddRange(SelectListHelper.GetBoolSelectList("Published", "Unpublished", selectedBool: model.Filter.Published, defaultText: "All"));
model.RatingOptions.AddRange(SelectListHelper.GetSelectList(Enumerable.Range(1, 4).Reverse(),
(x) => new SelectListItem <int>(text: $"{"star".ToQuantity(x)} or more", value: x.ToString(), selected: x == model.Filter.Rating)));
model.DiscountOptions.AddRange(SelectListHelper.GetSelectList(Enumerable.Range(1, 4).Select(x => x * 20).Reverse(),
(x) => new SelectListItem <int>(text: $"{x}% or more", value: x.ToString(), selected: x == model.Filter.Discount)));
var categories = await _categoryService.ListAsync(new CategoryFilter()
{
SellerId = seller.Id, Published = true
});
model.CategoryOptions.AddRange(SelectListHelper.GetSelectList(categories, x => new SelectListItem <Category>(text: x.Name, value: x.Slug, x.Slug == model.Filter.Search), defaultText: "All"));
model.Page = products.Page;
model.PageSize = products.PageSize;
model.PageFrom = products.PageFrom;
model.PageTo = products.PageTo;
model.TotalPages = products.TotalPages;
model.TotalItems = products.TotalItems;
}
