protected async Task <Address> PrepareAddress(SubmitReturnRequestModel model, IFormCollection form)
{
string pickupAddressId = form["pickup_address_id"];
var address = new Address();
if (_orderSettings.ReturnRequests_AllowToSpecifyPickupAddress)
{
if (!string.IsNullOrEmpty(pickupAddressId))
{
address = _workContext.CurrentCustomer.Addresses.FirstOrDefault(a => a.Id == pickupAddressId);
}
else
{
var customAttributes = await _addressViewModelService.ParseCustomAddressAttributes(form);
var customAttributeWarnings = await _addressViewModelService.GetAttributeWarnings(customAttributes);
foreach (var error in customAttributeWarnings)
{
ModelState.AddModelError("", error);
}
await TryUpdateModelAsync(model.NewAddress, "ReturnRequestNewAddress");
address = model.NewAddress.ToEntity();
model.NewAddressPreselected = true;
address.CustomAttributes = customAttributes;
address.CreatedOnUtc = DateTime.UtcNow;
}
}
return(address);
}
/// <summary>
/// Prepare the submit return request model
/// </summary>
/// <param name="model">Submit return request model</param>
/// <param name="subscription">Subscription</param>
/// <returns>Submit return request model</returns>
public virtual SubmitReturnRequestModel PrepareSubmitReturnRequestModel(SubmitReturnRequestModel model, Subscription subscription)
{
if (subscription == null)
{
throw new ArgumentNullException("subscription");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.SubscriptionId = subscription.Id;
model.AllowFiles = _subscriptionSettings.ReturnRequestsAllowFiles;
model.CustomSubscriptionNumber = subscription.CustomSubscriptionNumber;
//return reasons
model.AvailableReturnReasons = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTREASONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var reasons = new List <SubmitReturnRequestModel.ReturnRequestReasonModel>();
foreach (var rrr in _returnRequestService.GetAllReturnRequestReasons())
{
reasons.Add(new SubmitReturnRequestModel.ReturnRequestReasonModel
{
Id = rrr.Id,
Name = rrr.GetLocalized(x => x.Name)
});
}
return(reasons);
});
//return actions
model.AvailableReturnActions = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTACTIONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var actions = new List <SubmitReturnRequestModel.ReturnRequestActionModel>();
foreach (var rra in _returnRequestService.GetAllReturnRequestActions())
{
actions.Add(new SubmitReturnRequestModel.ReturnRequestActionModel
{
Id = rra.Id,
Name = rra.GetLocalized(x => x.Name)
});
}
return(actions);
});
//returnable articles
var subscriptionItems = subscription.SubscriptionItems.Where(oi => !oi.Article.NotReturnable);
foreach (var subscriptionItem in subscriptionItems)
{
var subscriptionItemModel = PrepareSubmitReturnRequestSubscriptionItemModel(subscriptionItem);
model.Items.Add(subscriptionItemModel);
}
return(model);
}
/// <summary>
/// Prepare the submit return request model
/// </summary>
/// <param name="model">Submit return request model</param>
/// <param name="order">Order</param>
/// <returns>Submit return request model</returns>
public virtual SubmitReturnRequestModel PrepareSubmitReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
model.OrderId = order.Id;
model.AllowFiles = _orderSettings.ReturnRequestsAllowFiles;
model.CustomOrderNumber = order.CustomOrderNumber;
//return reasons
model.AvailableReturnReasons = _cacheManager.Get(string.Format(NopModelCacheDefaults.ReturnRequestReasonsModelKey, _workContext.WorkingLanguage.Id),
() =>
{
var reasons = new List <SubmitReturnRequestModel.ReturnRequestReasonModel>();
foreach (var rrr in _returnRequestService.GetAllReturnRequestReasons())
{
reasons.Add(new SubmitReturnRequestModel.ReturnRequestReasonModel
{
Id = rrr.Id,
Name = _localizationService.GetLocalized(rrr, x => x.Name)
});
}
return(reasons);
});
//return actions
model.AvailableReturnActions = _cacheManager.Get(string.Format(NopModelCacheDefaults.ReturnRequestActionsModelKey, _workContext.WorkingLanguage.Id),
() =>
{
var actions = new List <SubmitReturnRequestModel.ReturnRequestActionModel>();
foreach (var rra in _returnRequestService.GetAllReturnRequestActions())
{
actions.Add(new SubmitReturnRequestModel.ReturnRequestActionModel
{
Id = rra.Id,
Name = _localizationService.GetLocalized(rra, x => x.Name)
});
}
return(actions);
});
//returnable products
var orderItems = order.OrderItems.Where(oi => !oi.Product.NotReturnable);
foreach (var orderItem in orderItems)
{
var orderItemModel = PrepareSubmitReturnRequestOrderItemModel(orderItem);
model.Items.Add(orderItemModel);
}
return(model);
}
public virtual SubmitReturnRequestModel PrepareSubmitReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
model.AllowFiles = _orderSettings.ReturnRequestsAllowFiles;
//return reasons
model.AvailableReturnReasons = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTREASONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var reasons = new List <SubmitReturnRequestModel.ReturnRequestReasonModel>();
foreach (var rrr in _returnRequestService.GetAllReturnRequestReasons())
{
reasons.Add(new SubmitReturnRequestModel.ReturnRequestReasonModel
{
Id = rrr.Id,
Name = rrr.GetLocalized(x => x.Name)
});
}
return(reasons);
});
//return actions
model.AvailableReturnActions = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTACTIONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var actions = new List <SubmitReturnRequestModel.ReturnRequestActionModel>();
foreach (var rra in _returnRequestService.GetAllReturnRequestActions())
{
actions.Add(new SubmitReturnRequestModel.ReturnRequestActionModel
{
Id = rra.Id,
Name = rra.GetLocalized(x => x.Name)
});
}
return(actions);
});
//returnable products
var orderItems = order.OrderItems.Where(oi => !oi.Product.NotReturnable);
foreach (var orderItem in orderItems)
{
var orderItemModel = PrepareSubmitReturnRequestOrderItemModel(orderItem);
model.Items.Add(orderItemModel);
}
return(model);
}
public ActionResult ReturnRequestSubmit(int orderId, SubmitReturnRequestModel model, FormCollection form)
{
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
return new HttpUnauthorizedResult();
if (!_orderProcessingService.IsReturnRequestAllowed(order))
return RedirectToRoute("HomePage");
int count = 0;
foreach (var orderItem in order.OrderItems)
{
int quantity = 0; //parse quantity
foreach (string formKey in form.AllKeys)
if (formKey.Equals(string.Format("quantity{0}", orderItem.Id), StringComparison.InvariantCultureIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
break;
}
if (quantity > 0)
{
var rr = new ReturnRequest
{
StoreId = _storeContext.CurrentStore.Id,
OrderItemId = orderItem.Id,
Quantity = quantity,
CustomerId = _workContext.CurrentCustomer.Id,
ReasonForReturn = model.ReturnReason,
RequestedAction = model.ReturnAction,
CustomerComments = model.Comments,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
_workContext.CurrentCustomer.ReturnRequests.Add(rr);
_customerService.UpdateCustomer(_workContext.CurrentCustomer);
//notify store owner here (email)
_workflowMessageService.SendNewReturnRequestStoreOwnerNotification(rr, orderItem, _localizationSettings.DefaultAdminLanguageId);
count++;
}
}
model = PrepareReturnRequestModel(model, order);
if (count > 0)
model.Result = _localizationService.GetResource("ReturnRequests.Submitted");
else
model.Result = _localizationService.GetResource("ReturnRequests.NoItemsSubmitted");
return View(model);
}
/// <returns>A task that represents the asynchronous operation</returns>
public virtual async Task<IActionResult> ReturnRequest(int orderId)
{
var order = await _orderService.GetOrderByIdAsync(orderId);
if (order == null || order.Deleted || (await _workContext.GetCurrentCustomerAsync()).Id != order.CustomerId)
return Challenge();
if (!await _orderProcessingService.IsReturnRequestAllowedAsync(order))
return RedirectToRoute("Homepage");
var model = new SubmitReturnRequestModel();
model = await _returnRequestModelFactory.PrepareSubmitReturnRequestModelAsync(model, order);
return View(model);
}
public ActionResult ReturnRequest(int orderId)
{
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
return new HttpUnauthorizedResult();
if (!_orderProcessingService.IsReturnRequestAllowed(order))
return RedirectToRoute("HomePage");
var model = new SubmitReturnRequestModel();
model = PrepareReturnRequestModel(model, order);
return View(model);
}
/// <summary>
/// Prepare the submit return request model
/// </summary>
/// <param name="model">Submit return request model</param>
/// <param name="order">Order</param>
/// <returns>Submit return request model</returns>
public virtual SubmitReturnRequestModel PrepareSubmitReturnRequestModel(SubmitReturnRequestModel model,
Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
model.OrderId = order.Id;
model.AllowFiles = _orderSettings.ReturnRequestsAllowFiles;
model.CustomOrderNumber = order.CustomOrderNumber;
//return reasons
model.AvailableReturnReasons = _returnRequestService.GetAllReturnRequestReasons()
.Select(rrr => new SubmitReturnRequestModel.ReturnRequestReasonModel
{
Id = rrr.Id,
Name = _localizationService.GetLocalized(rrr, x => x.Name)
}).ToList();
//return actions
model.AvailableReturnActions = _returnRequestService.GetAllReturnRequestActions()
.Select(rra => new SubmitReturnRequestModel.ReturnRequestActionModel
{
Id = rra.Id,
Name = _localizationService.GetLocalized(rra, x => x.Name)
})
.ToList();
//returnable products
var orderItems = _orderService.GetOrderItems(order.Id, isNotReturnable: false);
foreach (var orderItem in orderItems)
{
var orderItemModel = PrepareSubmitReturnRequestOrderItemModel(orderItem);
model.Items.Add(orderItemModel);
}
return(model);
}
public virtual IActionResult ReturnRequest(int orderId)
{
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(Challenge());
}
if (!_orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("HomePage"));
}
var model = new SubmitReturnRequestModel();
model = _returnRequestModelFactory.PrepareSubmitReturnRequestModel(model, order);
return(View(model));
}
public virtual ActionResult ReturnRequest(int subscriptionId)
{
var subscription = _subscriptionService.GetOrderById(subscriptionId);
if (subscription == null || subscription.Deleted || _workContext.CurrentCustomer.Id != subscription.CustomerId)
{
return(new HttpUnauthorizedResult());
}
if (!_subscriptionProcessingService.IsReturnRequestAllowed(subscription))
{
return(RedirectToRoute("HomePage"));
}
var model = new SubmitReturnRequestModel();
model = _returnRequestModelFactory.PrepareSubmitReturnRequestModel(model, subscription);
return(View(model));
}
public virtual async Task <IActionResult> ReturnRequest(string orderId, string errors = "")
{
var order = await _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(Challenge());
}
if (!await _orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("HomePage"));
}
var model = new SubmitReturnRequestModel();
model = await _returnRequestViewModelService.PrepareReturnRequest(model, order);
model.Error = errors;
return(View(model));
}
public ActionResult ReturnRequest(int orderId)
{
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(new HttpUnauthorizedResult());
}
if (!_orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToAction("Index", "Home"));
}
CustomerNavigationModel navModel = new CustomerNavigationModel();
ViewData["NavModel"] = navModel;
var model = new SubmitReturnRequestModel();
model = PrepareReturnRequestModel(model, order);
ViewBag.Msg = new MessageModel();
return(View(model));
}
public async Task <IActionResult> ReturnRequest(int id /* orderId */)
{
var order = await _db.Orders
.Include(x => x.OrderItems)
.ThenInclude(x => x.Product)
.FindByIdAsync(id);
if (order == null || Services.WorkContext.CurrentCustomer.Id != order.CustomerId)
{
return(new UnauthorizedResult());
}
if (!_orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("Homepage"));
}
var model = new SubmitReturnRequestModel();
model = await PrepareReturnRequestModelAsync(model, order);
return(View(model));
}
protected SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
//return reasons
if (_orderSettings.ReturnRequestReasons != null)
{
foreach (var rrr in _orderSettings.ReturnRequestReasons)
{
model.AvailableReturnReasons.Add(new SelectListItem()
{
Text = rrr,
Value = rrr
});
}
}
//return actions
if (_orderSettings.ReturnRequestActions != null)
{
foreach (var rra in _orderSettings.ReturnRequestActions)
{
model.AvailableReturnActions.Add(new SelectListItem()
{
Text = rra,
Value = rra
});
}
}
//products
var orderProductVariants = _orderService.GetAllOrderProductVariants(order.Id, null, null, null, null, null, null);
foreach (var opv in orderProductVariants)
{
var opvModel = new SubmitReturnRequestModel.OrderProductVariantModel()
{
Id = opv.Id,
ProductId = opv.ProductVariant.ProductId,
ProductSeName = opv.ProductVariant.Product.GetSeName(),
AttributeInfo = opv.AttributeDescription,
Quantity = opv.Quantity
};
//product name
if (!String.IsNullOrEmpty(opv.ProductVariant.GetLocalized(x => x.Name)))
{
opvModel.ProductName = string.Format("{0} ({1})", opv.ProductVariant.Product.GetLocalized(x => x.Name), opv.ProductVariant.GetLocalized(x => x.Name));
}
else
{
opvModel.ProductName = opv.ProductVariant.Product.GetLocalized(x => x.Name);
}
model.Items.Add(opvModel);
//unit price
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var opvUnitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceExclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var opvUnitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceInclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
break;
}
}
return(model);
}
protected virtual SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
//return reasons
model.AvailableReturnReasons = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTREASONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var reasons = new List <SubmitReturnRequestModel.ReturnRequestReasonModel>();
foreach (var rrr in _returnRequestService.GetAllReturnRequestReasons())
{
reasons.Add(new SubmitReturnRequestModel.ReturnRequestReasonModel()
{
Id = rrr.Id,
Name = rrr.GetLocalized(x => x.Name)
});
}
return(reasons);
});
//return actions
model.AvailableReturnActions = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTACTIONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var actions = new List <SubmitReturnRequestModel.ReturnRequestActionModel>();
foreach (var rra in _returnRequestService.GetAllReturnRequestActions())
{
actions.Add(new SubmitReturnRequestModel.ReturnRequestActionModel()
{
Id = rra.Id,
Name = rra.GetLocalized(x => x.Name)
});
}
return(actions);
});
//products
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
AttributeInfo = orderItem.AttributeDescription,
Quantity = orderItem.Quantity
};
model.Items.Add(orderItemModel);
//unit price
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
return(model);
}
public virtual async Task <IActionResult> ReturnRequestSubmit(int orderId, SubmitReturnRequestModel model, IFormCollection form)
{
var order = await _orderService.GetOrderByIdAsync(orderId);
if (order == null || order.Deleted || (await _workContext.GetCurrentCustomerAsync()).Id != order.CustomerId)
{
return(Challenge());
}
if (!await _orderProcessingService.IsReturnRequestAllowedAsync(order))
{
return(RedirectToRoute("Homepage"));
}
var count = 0;
var downloadId = 0;
if (_orderSettings.ReturnRequestsAllowFiles)
{
var download = await _downloadService.GetDownloadByGuidAsync(model.UploadedFileGuid);
if (download != null)
{
downloadId = download.Id;
}
}
//returnable products
var orderItems = await _orderService.GetOrderItemsAsync(order.Id, isNotReturnable : false);
foreach (var orderItem in orderItems)
{
var quantity = 0; //parse quantity
foreach (var formKey in form.Keys)
{
if (formKey.Equals($"quantity{orderItem.Id}", StringComparison.InvariantCultureIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
break;
}
}
if (quantity > 0)
{
var rrr = await _returnRequestService.GetReturnRequestReasonByIdAsync(model.ReturnRequestReasonId);
var rra = await _returnRequestService.GetReturnRequestActionByIdAsync(model.ReturnRequestActionId);
var rr = new ReturnRequest
{
CustomNumber = "",
StoreId = (await _storeContext.GetCurrentStoreAsync()).Id,
OrderItemId = orderItem.Id,
Quantity = quantity,
CustomerId = (await _workContext.GetCurrentCustomerAsync()).Id,
ReasonForReturn = rrr != null ? await _localizationService.GetLocalizedAsync(rrr, x => x.Name) : "not available",
RequestedAction = rra != null ? await _localizationService.GetLocalizedAsync(rra, x => x.Name) : "not available",
CustomerComments = model.Comments,
UploadedFileId = downloadId,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
await _returnRequestService.InsertReturnRequestAsync(rr);
//set return request custom number
rr.CustomNumber = _customNumberFormatter.GenerateReturnRequestCustomNumber(rr);
await _customerService.UpdateCustomerAsync(await _workContext.GetCurrentCustomerAsync());
await _returnRequestService.UpdateReturnRequestAsync(rr);
//notify store owner
await _workflowMessageService.SendNewReturnRequestStoreOwnerNotificationAsync(rr, orderItem, order, _localizationSettings.DefaultAdminLanguageId);
//notify customer
await _workflowMessageService.SendNewReturnRequestCustomerNotificationAsync(rr, orderItem, order);
count++;
}
}
model = await _returnRequestModelFactory.PrepareSubmitReturnRequestModelAsync(model, order);
if (count > 0)
{
model.Result = await _localizationService.GetResourceAsync("ReturnRequests.Submitted");
}
else
{
model.Result = await _localizationService.GetResourceAsync("ReturnRequests.NoItemsSubmitted");
}
return(View(model));
}
protected SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
var language = Services.WorkContext.WorkingLanguage;
string returnRequestReasons = _orderSettings.GetLocalized(x => x.ReturnRequestReasons, order.CustomerLanguageId, true, false);
string returnRequestActions = _orderSettings.GetLocalized(x => x.ReturnRequestActions, order.CustomerLanguageId, true, false);
// Return reasons.
foreach (var rrr in returnRequestReasons.SplitSafe(","))
{
model.AvailableReturnReasons.Add(new SelectListItem {
Text = rrr, Value = rrr
});
}
// Return actions.
foreach (var rra in returnRequestActions.SplitSafe(","))
{
model.AvailableReturnActions.Add(new SelectListItem {
Text = rra, Value = rra
});
}
// Products.
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
AttributeInfo = orderItem.AttributeDescription,
Quantity = orderItem.Quantity
};
orderItemModel.ProductUrl = _productUrlHelper.GetProductUrl(orderItemModel.ProductSeName, orderItem);
// Unit price.
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
}
break;
}
model.Items.Add(orderItemModel);
}
return(model);
}
protected virtual SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
model.OrderNumber = _orderService.GetOrderById(order.Id).OrderNumber;
//return reasons
model.AvailableReturnReasons = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTREASONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var reasons = new List <SubmitReturnRequestModel.ReturnRequestReasonModel>();
foreach (var rrr in _returnRequestService.GetAllReturnRequestReasons())
{
reasons.Add(new SubmitReturnRequestModel.ReturnRequestReasonModel()
{
Id = rrr.Id,
Name = rrr.GetLocalized(x => x.Name)
});
}
return(reasons);
});
//return actions
model.AvailableReturnActions = _cacheManager.Get(string.Format(ModelCacheEventConsumer.RETURNREQUESTACTIONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
() =>
{
var actions = new List <SubmitReturnRequestModel.ReturnRequestActionModel>();
foreach (var rra in _returnRequestService.GetAllReturnRequestActions())
{
actions.Add(new SubmitReturnRequestModel.ReturnRequestActionModel()
{
Id = rra.Id,
Name = rra.GetLocalized(x => x.Name)
});
}
return(actions);
});
var shipments = Grand.Core.Infrastructure.EngineContextExperimental.Current.Resolve <Grand.Services.Shipping.IShipmentService>().GetShipmentsByOrder(order.Id);
//products
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var qtyDelivery = shipments.Where(x => x.DeliveryDateUtc.HasValue).SelectMany(x => x.ShipmentItems).Where(x => x.OrderItemId == orderItem.Id).Sum(x => x.Quantity);
var qtyReturn = _returnRequestService.SearchReturnRequests(customerId: order.CustomerId, orderItemId: orderItem.Id).Sum(x => x.Quantity);
var product = _productService.GetProductByIdIncludeArch(orderItem.ProductId);
if (!product.NotReturnable)
{
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = orderItem.ProductId,
ProductName = product.GetLocalized(x => x.Name),
ProductSeName = product.GetSeName(),
AttributeInfo = orderItem.AttributeDescription,
Quantity = qtyDelivery - qtyReturn,
};
model.Items.Add(orderItemModel);
//unit price
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
}
return(model);
}
public virtual async Task <IActionResult> ReturnRequestSubmit(string orderId, SubmitReturnRequestModel model, IFormCollection form)
{
var order = await _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(Challenge());
}
if (!await _orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("HomePage"));
}
string pD = form["pickupDate"];
DateTime pickupDate = default(DateTime);
if (!string.IsNullOrEmpty(pD))
{
pickupDate = DateTime.ParseExact(form["pickupDate"], "MM/dd/yyyy", CultureInfo.InvariantCulture);
}
else if (_orderSettings.ReturnRequests_AllowToSpecifyPickupDate && _orderSettings.ReturnRequests_PickupDateRequired)
{
ModelState.AddModelError("", _localizationService.GetResource("ReturnRequests.PickupDateRequired"));
}
string pickupAddressId = form["pickup_address_id"];
var address = new Address();
if (_orderSettings.ReturnRequests_AllowToSpecifyPickupAddress)
{
if (!string.IsNullOrEmpty(pickupAddressId))
{
address = _workContext.CurrentCustomer.Addresses.FirstOrDefault(a => a.Id == pickupAddressId);
}
else
{
var customAttributes = await _addressViewModelService.ParseCustomAddressAttributes(form);
var customAttributeWarnings = await _addressViewModelService.GetAttributeWarnings(customAttributes);
foreach (var error in customAttributeWarnings)
{
ModelState.AddModelError("", error);
}
address = model.NewAddress.ToEntity();
model.NewAddressPreselected = true;
address.CustomAttributes = customAttributes;
address.CreatedOnUtc = DateTime.UtcNow;
}
}
if (!ModelState.IsValid && ModelState.ErrorCount > 0)
{
model.Error = string.Join(", ", ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
model = await _returnRequestViewModelService.PrepareReturnRequest(model, order);
return(View(model));
}
var rr = new ReturnRequest
{
StoreId = _storeContext.CurrentStore.Id,
OrderId = order.Id,
CustomerId = _workContext.CurrentCustomer.Id,
CustomerComments = model.Comments,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow,
PickupAddress = address,
PickupDate = pickupDate
};
int count = 0;
foreach (var orderItem in order.OrderItems)
{
var product = await _productService.GetProductById(orderItem.ProductId);
if (!product.NotReturnable)
{
int quantity = 0; //parse quantity
string rrrId = "";
string rraId = "";
foreach (string formKey in form.Keys)
{
if (formKey.Equals(string.Format("quantity{0}", orderItem.Id), StringComparison.OrdinalIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
}
if (formKey.Equals(string.Format("reason{0}", orderItem.Id), StringComparison.OrdinalIgnoreCase))
{
rrrId = form[formKey];
}
if (formKey.Equals(string.Format("action{0}", orderItem.Id), StringComparison.OrdinalIgnoreCase))
{
rraId = form[formKey];
}
}
if (quantity > 0)
{
var rrr = await _returnRequestService.GetReturnRequestReasonById(rrrId);
var rra = await _returnRequestService.GetReturnRequestActionById(rraId);
rr.ReturnRequestItems.Add(new ReturnRequestItem
{
RequestedAction = rra != null ? rra.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id) : "not available",
ReasonForReturn = rrr != null ? rrr.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id) : "not available",
Quantity = quantity,
OrderItemId = orderItem.Id
});
count++;
}
}
}
model = await _returnRequestViewModelService.PrepareReturnRequest(model, order);
if (count > 0)
{
await _returnRequestService.InsertReturnRequest(rr);
model.Result = string.Format(_localizationService.GetResource("ReturnRequests.Submitted"), rr.ReturnNumber, Url.Link("ReturnRequestDetails", new { returnRequestId = rr.Id }));
//notify store owner here (email)
await _workflowMessageService.SendNewReturnRequestStoreOwnerNotification(rr, order, _localizationSettings.DefaultAdminLanguageId);
//notify customer
await _workflowMessageService.SendNewReturnRequestCustomerNotification(rr, order, order.CustomerLanguageId);
}
else
{
model.Error = _localizationService.GetResource("ReturnRequests.NoItemsSubmitted");
return(View(model));
}
return(View(model));
}
protected virtual SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
//return reasons
if (_orderSettings.ReturnRequestReasons != null)
{
foreach (var rrr in _orderSettings.ReturnRequestReasons)
{
model.AvailableReturnReasons.Add(new SelectListItem
{
Text = rrr,
Value = rrr
});
}
}
//return actions
if (_orderSettings.ReturnRequestActions != null)
{
foreach (var rra in _orderSettings.ReturnRequestActions)
{
model.AvailableReturnActions.Add(new SelectListItem
{
Text = rra,
Value = rra
});
}
}
//products
var orderItems = _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = orderItem.Product.GetSeName(),
AttributeInfo = orderItem.AttributeDescription,
Quantity = orderItem.Quantity
};
model.Items.Add(orderItemModel);
//unit price
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
return(model);
}
//[ValidateInput(false)]
////[PublicAntiForgery]
public virtual IActionResult ReturnRequestSubmit(string orderId, SubmitReturnRequestModel model, IFormCollection form)
{
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(new UnauthorizedResult());
}
if (!_orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("HomePage"));
}
int count = 0;
foreach (var orderItem in order.OrderItems)
{
var product = _productService.GetProductById(orderItem.ProductId);
if (!product.NotReturnable)
{
int quantity = 0; //parse quantity
foreach (string formKey in form.Keys)
{
if (formKey.Equals(string.Format("quantity{0}", orderItem.Id), StringComparison.OrdinalIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
break;
}
}
if (quantity > 0)
{
var rrr = _returnRequestService.GetReturnRequestReasonById(model.ReturnRequestReasonId);
var rra = _returnRequestService.GetReturnRequestActionById(model.ReturnRequestActionId);
var rr = new ReturnRequest
{
StoreId = _storeContext.CurrentStore.Id,
OrderId = order.Id,
OrderItemId = orderItem.Id,
Quantity = quantity,
CustomerId = _workContext.CurrentCustomer.Id,
ReasonForReturn = rrr != null?rrr.GetLocalized(x => x.Name) : "not available",
RequestedAction = rra != null?rra.GetLocalized(x => x.Name) : "not available",
CustomerComments = model.Comments,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
_returnRequestService.InsertReturnRequest(rr);
//notify store owner here (email)
_workflowMessageService.SendNewReturnRequestStoreOwnerNotification(rr, orderItem, _localizationSettings.DefaultAdminLanguageId);
//notify customer
_workflowMessageService.SendNewReturnRequestCustomerNotification(rr, orderItem, order.CustomerLanguageId);
count++;
}
}
}
model = PrepareReturnRequestModel(model, order);
if (count > 0)
{
model.Result = _localizationService.GetResource("ReturnRequests.Submitted");
}
else
{
model.Result = _localizationService.GetResource("ReturnRequests.NoItemsSubmitted");
}
return(View(model));
}
public virtual async Task <IActionResult> ReturnRequestSubmit(string orderId, SubmitReturnRequestModel model, IFormCollection form)
{
var order = await _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(Challenge());
}
if (!await _orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("HomePage"));
}
ModelState.Clear();
string pD = form["pickupDate"];
DateTime pickupDate = default(DateTime);
if (!string.IsNullOrEmpty(pD))
{
pickupDate = DateTime.ParseExact(form["pickupDate"], "MM/dd/yyyy", CultureInfo.InvariantCulture);
}
else if (_orderSettings.ReturnRequests_AllowToSpecifyPickupDate && _orderSettings.ReturnRequests_PickupDateRequired)
{
ModelState.AddModelError("", _localizationService.GetResource("ReturnRequests.PickupDateRequired"));
}
var address = await PrepareAddress(model, form);
if (!ModelState.IsValid && ModelState.ErrorCount > 0)
{
model.Error = string.Join(", ", ModelState.Keys.SelectMany(k => ModelState[k].Errors).Select(m => m.ErrorMessage).ToArray());
model = await _returnRequestViewModelService.PrepareReturnRequest(model, order);
return(View(model));
}
var result = await _returnRequestViewModelService.ReturnRequestSubmit(model, order, address, pickupDate, form);
if (result.rr.ReturnNumber > 0)
{
model.Result = string.Format(_localizationService.GetResource("ReturnRequests.Submitted"), result.rr.ReturnNumber, Url.Link("ReturnRequestDetails", new { returnRequestId = result.rr.Id }));
}
return(View(result.model));
}
public virtual async Task <(SubmitReturnRequestModel model, ReturnRequest rr)> ReturnRequestSubmit(SubmitReturnRequestModel model, Order order, Address address, DateTime pickupDate, IFormCollection form)
{
var rr = new ReturnRequest {
StoreId = _storeContext.CurrentStore.Id,
OrderId = order.Id,
CustomerId = _workContext.CurrentCustomer.Id,
CustomerComments = model.Comments,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow,
PickupAddress = address,
PickupDate = pickupDate
};
foreach (var orderItem in order.OrderItems)
{
var product = await _productService.GetProductById(orderItem.ProductId);
if (!product.NotReturnable)
{
int quantity = 0; //parse quantity
string rrrId = "";
string rraId = "";
foreach (string formKey in form.Keys)
{
if (formKey.Equals(string.Format("quantity{0}", orderItem.Id), StringComparison.OrdinalIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
}
if (formKey.Equals(string.Format("reason{0}", orderItem.Id), StringComparison.OrdinalIgnoreCase))
{
rrrId = form[formKey];
}
if (formKey.Equals(string.Format("action{0}", orderItem.Id), StringComparison.OrdinalIgnoreCase))
{
rraId = form[formKey];
}
}
if (quantity > 0)
{
var rrr = await _returnRequestService.GetReturnRequestReasonById(rrrId);
var rra = await _returnRequestService.GetReturnRequestActionById(rraId);
rr.ReturnRequestItems.Add(new ReturnRequestItem {
RequestedAction = rra != null ? rra.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id) : "not available",
ReasonForReturn = rrr != null ? rrr.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id) : "not available",
Quantity = quantity,
OrderItemId = orderItem.Id
});
}
}
}
model = await PrepareReturnRequest(model, order);
if (rr.ReturnRequestItems.Any())
{
await _returnRequestService.InsertReturnRequest(rr);
//notify store owner here (email)
await _workflowMessageService.SendNewReturnRequestStoreOwnerNotification(rr, order, _localizationSettings.DefaultAdminLanguageId);
//notify customer
await _workflowMessageService.SendNewReturnRequestCustomerNotification(rr, order, order.CustomerLanguageId);
}
else
{
model.Error = _localizationService.GetResource("ReturnRequests.NoItemsSubmitted");
}
return(model, rr);
}
public virtual async Task <SubmitReturnRequestModel> PrepareReturnRequest(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
model.OrderNumber = (await _orderService.GetOrderById(order.Id)).OrderNumber;
//return reasons
model.AvailableReturnReasons = await _cacheManager.GetAsync(string.Format(ModelCacheEventConsumer.RETURNREQUESTREASONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
async() =>
{
var reasons = new List <SubmitReturnRequestModel.ReturnRequestReasonModel>();
foreach (var rrr in await _returnRequestService.GetAllReturnRequestReasons())
{
reasons.Add(new SubmitReturnRequestModel.ReturnRequestReasonModel()
{
Id = rrr.Id,
Name = rrr.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id)
});
}
return(reasons);
});
//return actions
model.AvailableReturnActions = await _cacheManager.GetAsync(string.Format(ModelCacheEventConsumer.RETURNREQUESTACTIONS_MODEL_KEY, _workContext.WorkingLanguage.Id),
async() =>
{
var actions = new List <SubmitReturnRequestModel.ReturnRequestActionModel>();
foreach (var rra in await _returnRequestService.GetAllReturnRequestActions())
{
actions.Add(new SubmitReturnRequestModel.ReturnRequestActionModel()
{
Id = rra.Id,
Name = rra.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id)
});
}
return(actions);
});
var shipments = await _serviceProvider.GetRequiredService <Grand.Services.Shipping.IShipmentService>().GetShipmentsByOrder(order.Id);
//products
var orderItems = await _orderService.GetAllOrderItems(order.Id, null, null, null, null, null, null);
foreach (var orderItem in orderItems)
{
var qtyDelivery = shipments.Where(x => x.DeliveryDateUtc.HasValue).SelectMany(x => x.ShipmentItems).Where(x => x.OrderItemId == orderItem.Id).Sum(x => x.Quantity);
var returnRequests = await _returnRequestService.SearchReturnRequests(customerId : order.CustomerId, orderItemId : orderItem.Id);
int qtyReturn = 0;
foreach (var rr in returnRequests)
{
foreach (var rrItem in rr.ReturnRequestItems)
{
qtyReturn += rrItem.Quantity;
}
}
var product = await _productService.GetProductByIdIncludeArch(orderItem.ProductId);
if (!product.NotReturnable)
{
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel {
Id = orderItem.Id,
ProductId = orderItem.ProductId,
ProductName = product.GetLocalized(x => x.Name, _workContext.WorkingLanguage.Id),
ProductSeName = product.GetSeName(_workContext.WorkingLanguage.Id),
AttributeInfo = orderItem.AttributeDescription,
Quantity = qtyDelivery - qtyReturn,
};
if (orderItemModel.Quantity > 0)
{
model.Items.Add(orderItemModel);
}
//unit price
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
}
if (_orderSettings.ReturnRequests_AllowToSpecifyPickupAddress)
{
//existing addresses
var addresses = new List <Address>();
foreach (var item in _workContext.CurrentCustomer.Addresses)
{
if (string.IsNullOrEmpty(item.CountryId))
{
addresses.Add(item);
continue;
}
var country = await _countryService.GetCountryById(item.CountryId);
if (country == null || (country.AllowsShipping && _storeMappingService.Authorize(country)))
{
addresses.Add(item);
continue;
}
}
foreach (var address in addresses)
{
var addressModel = new AddressModel();
await _addressViewModelService.PrepareModel(model : addressModel,
address : address,
excludeProperties : false);
model.ExistingAddresses.Add(addressModel);
}
//new address
var countries = await _countryService.GetAllCountriesForShipping();
await _addressViewModelService.PrepareModel(model : model.NewAddress,
address : null,
excludeProperties : false,
loadCountries : () => countries,
prePopulateWithCustomerFields : true,
customer : _workContext.CurrentCustomer);
}
model.ShowPickupAddress = _orderSettings.ReturnRequests_AllowToSpecifyPickupAddress;
model.ShowPickupDate = _orderSettings.ReturnRequests_AllowToSpecifyPickupDate;
model.PickupDateRequired = _orderSettings.ReturnRequests_PickupDateRequired;
return(model);
}
/// <summary>
/// Prepare the submit return request model
/// </summary>
/// <param name="model">Submit return request model</param>
/// <param name="order">Order</param>
/// <returns>
/// A task that represents the asynchronous operation
/// The task result contains the submit return request model
/// </returns>
public virtual async Task <SubmitReturnRequestModel> PrepareSubmitReturnRequestModelAsync(SubmitReturnRequestModel model,
Order order)
{
if (order == null)
{
throw new ArgumentNullException(nameof(order));
}
if (model == null)
{
throw new ArgumentNullException(nameof(model));
}
model.OrderId = order.Id;
model.AllowFiles = _orderSettings.ReturnRequestsAllowFiles;
model.CustomOrderNumber = order.CustomOrderNumber;
//return reasons
model.AvailableReturnReasons = await(await _returnRequestService.GetAllReturnRequestReasonsAsync())
.SelectAwait(async rrr => new SubmitReturnRequestModel.ReturnRequestReasonModel
{
Id = rrr.Id,
Name = await _localizationService.GetLocalizedAsync(rrr, x => x.Name)
}).ToListAsync();
//return actions
model.AvailableReturnActions = await(await _returnRequestService.GetAllReturnRequestActionsAsync())
.SelectAwait(async rra => new SubmitReturnRequestModel.ReturnRequestActionModel
{
Id = rra.Id,
Name = await _localizationService.GetLocalizedAsync(rra, x => x.Name)
})
.ToListAsync();
//returnable products
model.Items = await PrepareSubmitReturnRequestOrderItemModelsAsync(order);
return(model);
}
private SubmitReturnRequestModel PrepareReturnRequestModel(SubmitReturnRequestModel model, Order order)
{
if (order == null)
{
throw new ArgumentNullException("order");
}
if (model == null)
{
throw new ArgumentNullException("model");
}
model.OrderId = order.Id;
//return reasons
if (_orderSettings.ReturnRequestReasons != null)
{
foreach (var rrr in _orderSettings.ReturnRequestReasons)
{
string sRrr = _localizationService.GetResource(rrr);
model.AvailableReturnReasons.Add(new SelectListItem()
{
Text = sRrr,
Value = sRrr
});
}
}
//return actions
if (_orderSettings.ReturnRequestActions != null)
{
foreach (var rra in _orderSettings.ReturnRequestActions)
{
string sRra = _localizationService.GetResource(rra);
model.AvailableReturnActions.Add(new SelectListItem()
{
Text = sRra,
Value = sRra
});
}
}
//products
var orderProductVariants = _orderService.GetAllOrderProductVariants(order.Id, null, null, null, null, null, null);
foreach (var opv in orderProductVariants)
{
var opvModel = new SubmitReturnRequestModel.OrderProductVariantModel()
{
Id = opv.Id,
ProductId = opv.ProductVariant.ProductId,
ProductSeName = opv.ProductVariant.Product.GetSeName(),
AttributeInfo = opv.AttributeDescription,
Quantity = opv.Quantity
};
for (int i = 1; i <= opvModel.Quantity; i++)
{
opvModel.SelectListProductQuantity.Add(new SelectListItem()
{
Value = i.ToString(),
Text = i.ToString()
}
);
}
var picture = opv.ProductVariant.GetDefaultProductVariantPicture(_pictureService);
if (picture == null)
{
picture = _pictureService.GetPicturesByProductId(opv.ProductVariant.Product.Id, 1).FirstOrDefault();
}
var pictureModel = new PictureModel()
{
ImageUrl = _pictureService.GetPictureUrl(picture, _mediaSettings.CartThumbPictureSize, true),
Title = string.Format(_localizationService.GetResource("Media.Product.ImageLinkTitleFormat"), opv.ProductVariant.Product.Name),
AlternateText = string.Format(_localizationService.GetResource("Media.Product.ImageAlternateTextFormat"), opv.ProductVariant.Name),
};
opvModel.Picture = pictureModel;
opvModel.ManufacturerName = opv.ProductVariant.Product.ManufacturerName();
opvModel.Sku = opv.ProductVariant.Sku;
//product name
if (!String.IsNullOrEmpty(opv.ProductVariant.GetLocalized(x => x.Name)))
{
opvModel.ProductName = string.Format("{0} ({1})", opv.ProductVariant.Product.GetLocalized(x => x.Name), opv.ProductVariant.GetLocalized(x => x.Name));
}
else
{
opvModel.ProductName = opv.ProductVariant.Product.GetLocalized(x => x.Name);
}
model.Items.Add(opvModel);
//unit price
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
var opvUnitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceExclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
break;
case TaxDisplayType.IncludingTax:
{
var opvUnitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(opv.UnitPriceInclTax, order.CurrencyRate);
opvModel.UnitPrice = _priceFormatter.FormatPrice(opvUnitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
break;
}
}
return(model);
}
public ActionResult ReturnRequestSubmit(int orderId, SubmitReturnRequestModel model, FormCollection form)
{
//TempData["ReturnRequestSuccess"] = null;
CustomerNavigationModel navModel = new CustomerNavigationModel();
ViewData["NavModel"] = navModel;
MessageModel msg = new MessageModel();
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(new HttpUnauthorizedResult());
}
if (!_orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToAction("Index", "Home"));
}
int count = 0;
foreach (var opv in order.OrderProductVariants)
{
int quantity = 0; //parse quantity
bool selection = false;
foreach (string formKey in form.AllKeys)
{
if (formKey.Equals(string.Format("quantity{0}", opv.Id), StringComparison.InvariantCultureIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
continue;
}
if (formKey.Equals(string.Format("selection{0}", opv.Id), StringComparison.InvariantCultureIgnoreCase))
{
bool.TryParse(form[formKey], out selection);
continue;
}
}
if (selection && quantity > 0)
{
var rr = new ReturnRequest()
{
OrderProductVariantId = opv.Id,
Quantity = quantity,
CustomerId = _workContext.CurrentCustomer.Id,
ReasonForReturn = model.ReturnReason,
RequestedAction = model.ReturnAction,
CustomerComments = model.Comments,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
_workContext.CurrentCustomer.ReturnRequests.Add(rr);
_customerService.UpdateCustomer(_workContext.CurrentCustomer);
//notify store owner here (email)
_workflowMessageService.SendNewReturnRequestStoreOwnerNotification(rr, opv, _localizationSettings.DefaultAdminLanguageId);
_workflowMessageService.SendNewReturnRequestCustomerNotification(_workContext.CurrentCustomer.GetFullName(), _workContext.CurrentCustomer.Email, model.OrderId.ToString(), _workContext.WorkingLanguage.Id);
count++;
}
}
if (count > 0)
{
msg.Successful = true;
msg.MessageList.Add(_localizationService.GetResource("ReturnRequests.Submitted", _workContext.WorkingLanguage.Id));
TempData["ReturnRequestSuccess"] = msg;
return(RedirectToAction("Details", new { orderId = orderId }));
}
else
{
msg.Successful = false;
msg.MessageList.Add(_localizationService.GetResource("ReturnRequests.NoItemsSubmitted", _workContext.WorkingLanguage.Id));
ViewBag.Msg = msg;
}
model = PrepareReturnRequestModel(new SubmitReturnRequestModel(), order);
ViewBag.Msg = msg;
return(View("ReturnRequest", model));
}
protected async Task <SubmitReturnRequestModel> PrepareReturnRequestModelAsync(SubmitReturnRequestModel model, Order order)
{
Guard.NotNull(order, nameof(order));
Guard.NotNull(model, nameof(model));
model.OrderId = order.Id;
var language = Services.WorkContext.WorkingLanguage;
string returnRequestReasons = _orderSettings.GetLocalizedSetting(x => x.ReturnRequestReasons, order.CustomerLanguageId, order.StoreId, true, false);
string returnRequestActions = _orderSettings.GetLocalizedSetting(x => x.ReturnRequestActions, order.CustomerLanguageId, order.StoreId, true, false);
// Return reasons.
var availableReturnReasons = new List <SelectListItem>();
foreach (var rrr in returnRequestReasons.SplitSafe(","))
{
availableReturnReasons.Add(new SelectListItem {
Text = rrr, Value = rrr
});
}
ViewBag.AvailableReturnReasons = availableReturnReasons;
// Return actions.
var availableReturnActions = new List <SelectListItem>();
foreach (var rra in returnRequestActions.SplitSafe(","))
{
availableReturnActions.Add(new SelectListItem {
Text = rra, Value = rra
});
}
ViewBag.AvailableReturnActions = availableReturnActions;
foreach (var orderItem in order.OrderItems)
{
var orderItemModel = new SubmitReturnRequestModel.OrderItemModel
{
Id = orderItem.Id,
ProductId = orderItem.Product.Id,
ProductName = orderItem.Product.GetLocalized(x => x.Name),
ProductSeName = await orderItem.Product.GetActiveSlugAsync(),
AttributeInfo = orderItem.AttributeDescription,
Quantity = orderItem.Quantity
};
orderItemModel.ProductUrl = await _productUrlHelper.GetProductUrlAsync(orderItemModel.ProductSeName, orderItem);
// TODO: (mh) (core) Reconsider when pricing is available.
var customerCurrency = await _db.Currencies
.AsNoTracking()
.Where(x => x.CurrencyCode == order.CustomerCurrencyCode)
.FirstOrDefaultAsync() ?? new Currency
{
CurrencyCode = order.CustomerCurrencyCode
};
// Unit price.
switch (order.CustomerTaxDisplayType)
{
case TaxDisplayType.ExcludingTax:
{
// TODO: (mh) (core) _currencyService.ConvertToCurrency doesn't take a rate as paramter.
//var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
//orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, false);
orderItemModel.UnitPrice = new Money(orderItem.UnitPriceExclTax, customerCurrency);
}
break;
case TaxDisplayType.IncludingTax:
{
//var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
//orderItemModel.UnitPrice = _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, order.CustomerCurrencyCode, language, true);
orderItemModel.UnitPrice = new Money(orderItem.UnitPriceInclTax, customerCurrency);
}
break;
}
model.Items.Add(orderItemModel);
}
return(model);
}
public virtual ActionResult ReturnRequestSubmit(int orderId, SubmitReturnRequestModel model, FormCollection form)
{
var order = _orderService.GetOrderById(orderId);
if (order == null || order.Deleted || _workContext.CurrentCustomer.Id != order.CustomerId)
{
return(new HttpUnauthorizedResult());
}
if (!_orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("HomePage"));
}
int count = 0;
var downloadId = 0;
if (_orderSettings.ReturnRequestsAllowFiles)
{
var download = _downloadService.GetDownloadByGuid(model.UploadedFileGuid);
if (download != null)
{
downloadId = download.Id;
}
}
//returnable products
var orderItems = order.OrderItems.Where(oi => !oi.Product.NotReturnable);
foreach (var orderItem in orderItems)
{
int quantity = 0; //parse quantity
foreach (string formKey in form.AllKeys)
{
if (formKey.Equals(string.Format("quantity{0}", orderItem.Id), StringComparison.InvariantCultureIgnoreCase))
{
int.TryParse(form[formKey], out quantity);
break;
}
}
if (quantity > 0)
{
var rrr = _returnRequestService.GetReturnRequestReasonById(model.ReturnRequestReasonId);
var rra = _returnRequestService.GetReturnRequestActionById(model.ReturnRequestActionId);
var rr = new ReturnRequest
{
CustomNumber = "",
StoreId = _storeContext.CurrentStore.Id,
OrderItemId = orderItem.Id,
Quantity = quantity,
CustomerId = _workContext.CurrentCustomer.Id,
ReasonForReturn = rrr != null?rrr.GetLocalized(x => x.Name) : "not available",
RequestedAction = rra != null?rra.GetLocalized(x => x.Name) : "not available",
CustomerComments = model.Comments,
UploadedFileId = downloadId,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending,
CreatedOnUtc = DateTime.UtcNow,
UpdatedOnUtc = DateTime.UtcNow
};
_workContext.CurrentCustomer.ReturnRequests.Add(rr);
_customerService.UpdateCustomer(_workContext.CurrentCustomer);
//set return request custom number
rr.CustomNumber = _customNumberFormatter.GenerateReturnRequestCustomNumber(rr);
_customerService.UpdateCustomer(_workContext.CurrentCustomer);
//notify store owner
_workflowMessageService.SendNewReturnRequestStoreOwnerNotification(rr, orderItem, _localizationSettings.DefaultAdminLanguageId);
//notify customer
_workflowMessageService.SendNewReturnRequestCustomerNotification(rr, orderItem, order.CustomerLanguageId);
count++;
}
}
model = _returnRequestModelFactory.PrepareSubmitReturnRequestModel(model, order);
if (count > 0)
{
model.Result = _localizationService.GetResource("ReturnRequests.Submitted");
}
else
{
model.Result = _localizationService.GetResource("ReturnRequests.NoItemsSubmitted");
}
return(View(model));
}
public async Task <IActionResult> ReturnRequestSubmit(int id /* orderId */, SubmitReturnRequestModel model)
{
var order = await _db.Orders.FindByIdAsync(id);
var customer = Services.WorkContext.CurrentCustomer;
if (order == null || customer.Id != order.CustomerId)
{
return(new UnauthorizedResult());
}
if (!_orderProcessingService.IsReturnRequestAllowed(order))
{
return(RedirectToRoute("Homepage"));
}
foreach (var orderItem in order.OrderItems)
{
var form = Request.Form;
var quantity = 0;
foreach (var formKey in form.Keys)
{
if (formKey.EqualsNoCase($"quantity{orderItem.Id}"))
{
_ = int.TryParse(form[formKey], out quantity);
break;
}
}
if (quantity > 0)
{
var rr = new ReturnRequest
{
StoreId = Services.StoreContext.CurrentStore.Id,
OrderItemId = orderItem.Id,
Quantity = quantity,
CustomerId = customer.Id,
ReasonForReturn = model.ReturnReason,
RequestedAction = model.ReturnAction,
CustomerComments = model.Comments,
StaffNotes = string.Empty,
ReturnRequestStatus = ReturnRequestStatus.Pending
};
customer.ReturnRequests.Add(rr);
_db.TryUpdate(customer);
await _db.SaveChangesAsync();
model.AddedReturnRequestIds.Add(rr.Id);
// Notify store owner here by sending an email.
await _messageFactory.SendNewReturnRequestStoreOwnerNotificationAsync(rr, orderItem, _localizationSettings.DefaultAdminLanguageId);
}
}
model = await PrepareReturnRequestModelAsync(model, order);
if (model.AddedReturnRequestIds.Any())
{
model.Result = T("ReturnRequests.Submitted");
}
else
{
NotifyWarning(T("ReturnRequests.NoItemsSubmitted"));
}
return(View(model));
}
