private async Task PrepareItems(GetReturnRequest request, ReturnRequestModel model)
{
var shipments = await _shipmentService.GetShipmentsByOrder(request.Order.Id);
foreach (var orderItem in request.Order.OrderItems)
{
var qtyDelivery = shipments.Where(x => x.DeliveryDateUtc.HasValue).SelectMany(x => x.ShipmentItems).Where(x => x.OrderItemId == orderItem.Id).Sum(x => x.Quantity);
var query = new GetReturnRequestQuery()
{
StoreId = request.Store.Id,
};
var returnRequests = await _returnRequestService.SearchReturnRequests(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 ReturnRequestModel.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,
VendorId = orderItem.VendorId,
VendorName = string.IsNullOrEmpty(orderItem.VendorId) ? "" : (await _vendorService.GetVendorById(orderItem.VendorId))?.Name,
Quantity = qtyDelivery - qtyReturn,
};
if (orderItemModel.Quantity > 0)
{
model.Items.Add(orderItemModel);
}
//unit price
if (request.Order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, request.Order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPrice(unitPriceInclTaxInCustomerCurrency, true, request.Order.CustomerCurrencyCode, _workContext.WorkingLanguage, true);
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, request.Order.CurrencyRate);
orderItemModel.UnitPrice = await _priceFormatter.FormatPrice(unitPriceExclTaxInCustomerCurrency, true, request.Order.CustomerCurrencyCode, _workContext.WorkingLanguage, false);
}
}
}
}
public async Task <CustomerReturnRequestsModel> Handle(GetReturnRequests request, CancellationToken cancellationToken)
{
var model = new CustomerReturnRequestsModel();
var query = new GetReturnRequestQuery()
{
StoreId = request.Store.Id,
};
if (request.Customer.IsOwner())
{
query.OwnerId = request.Customer.Id;
}
else
{
query.CustomerId = request.Customer.Id;
}
var returnRequests = await _mediator.Send(query);
foreach (var returnRequest in returnRequests)
{
var order = await _orderService.GetOrderById(returnRequest.OrderId);
decimal total = 0;
foreach (var rrItem in returnRequest.ReturnRequestItems)
{
var orderItem = order.OrderItems.Where(x => x.Id == rrItem.OrderItemId).First();
if (order.CustomerTaxDisplayType == TaxDisplayType.IncludingTax)
{
//including tax
var unitPriceInclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceInclTax, order.CurrencyRate);
total += unitPriceInclTaxInCustomerCurrency * rrItem.Quantity;
}
else
{
//excluding tax
var unitPriceExclTaxInCustomerCurrency = _currencyService.ConvertCurrency(orderItem.UnitPriceExclTax, order.CurrencyRate);
total += unitPriceExclTaxInCustomerCurrency * rrItem.Quantity;
}
}
var itemModel = new CustomerReturnRequestsModel.ReturnRequestModel {
Id = returnRequest.Id,
ReturnNumber = returnRequest.ReturnNumber,
ReturnRequestStatus = returnRequest.ReturnRequestStatus.GetLocalizedEnum(_localizationService, request.Language.Id),
CreatedOn = _dateTimeHelper.ConvertToUserTime(returnRequest.CreatedOnUtc, DateTimeKind.Utc),
ProductsCount = returnRequest.ReturnRequestItems.Sum(x => x.Quantity),
ReturnTotal = _priceFormatter.FormatPrice(total)
};
model.Items.Add(itemModel);
}
return(model);
}
public Task <IMongoQueryable <ReturnRequest> > Handle(GetReturnRequestQuery request, CancellationToken cancellationToken)
{
var query = _returnRequestRepository.Table;
if (!string.IsNullOrEmpty(request.StoreId))
{
query = query.Where(rr => request.StoreId == rr.StoreId);
}
if (!string.IsNullOrEmpty(request.CustomerId))
{
query = query.Where(rr => request.CustomerId == rr.CustomerId);
}
if (!string.IsNullOrEmpty(request.VendorId))
{
query = query.Where(rr => request.VendorId == rr.VendorId);
}
if (!string.IsNullOrEmpty(request.OwnerId))
{
query = query.Where(rr => request.OwnerId == rr.OwnerId);
}
if (request.Rs.HasValue)
{
var returnStatusId = (int)request.Rs.Value;
query = query.Where(rr => rr.ReturnRequestStatusId == returnStatusId);
}
if (!string.IsNullOrEmpty(request.OrderItemId))
{
query = query.Where(rr => rr.ReturnRequestItems.Any(x => x.OrderItemId == request.OrderItemId));
}
if (request.CreatedFromUtc.HasValue)
{
query = query.Where(rr => request.CreatedFromUtc.Value <= rr.CreatedOnUtc);
}
if (request.CreatedToUtc.HasValue)
{
query = query.Where(rr => request.CreatedToUtc.Value >= rr.CreatedOnUtc);
}
query = query.OrderByDescending(rr => rr.CreatedOnUtc).ThenByDescending(rr => rr.Id);
return(Task.FromResult(query));
}
/// <summary>
/// Search return requests
/// </summary>
/// <param name="storeId">Store identifier; 0 to load all entries</param>
/// <param name="customerId">Customer identifier; null to load all entries</param>
/// <param name="orderItemId">Order item identifier; 0 to load all entries</param>
/// <param name="createdFromUtc">Created date from (UTC); null to load all records</param>
/// <param name="createdToUtc">Created date to (UTC); null to load all records</param>
/// <param name="rs">Return request status; null to load all entries</param>
/// <param name="pageIndex">Page index</param>
/// <param name="pageSize">Page size</param>
/// <returns>Return requests</returns>
public virtual async Task <IPagedList <ReturnRequest> > SearchReturnRequests(string storeId = "", string customerId = "",
string orderItemId = "", ReturnRequestStatus?rs = null,
int pageIndex = 0, int pageSize = int.MaxValue, DateTime?createdFromUtc = null, DateTime?createdToUtc = null)
{
var model = new GetReturnRequestQuery()
{
CreatedFromUtc = createdFromUtc,
CreatedToUtc = createdToUtc,
PageIndex = pageIndex,
PageSize = pageSize,
CustomerId = customerId,
StoreId = storeId,
OrderItemId = orderItemId,
Rs = rs,
};
var query = await _mediator.Send(model);
return(await PagedList <ReturnRequest> .Create(query, pageIndex, pageSize));
}
