public async Task <List <HSLineItemOrder> > BuyerLineItemDetail(ListArgs <HSOrder> args, BuyerReportViewContext viewContext, string userID, string locationID, DecodedToken decodedToken)
{
IList <ListFilter> filters = new List <ListFilter>();
filters.Add(ApplyBuyerLineContext(viewContext, userID, locationID, decodedToken));
foreach (var filter in args.Filters)
{
filters.Add(ApplyBuyerLineFilter(filter));
}
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = -1,
Sort = "OrderID",
SortDirection = SortDirection.ASC,
Filters = filters,
};
IQueryable <LineItemDetailData> queryable = _lineItemDetail.GetQueryable()
.Where(order =>
order.PartitionKey == "PartitionValue");
QueryRequestOptions requestOptions = new QueryRequestOptions
{
MaxItemCount = listOptions.PageSize,
MaxConcurrency = -1
};
CosmosListPage <LineItemDetailData> lineItemDataResponse = await _lineItemDetail.GetItemsAsync(queryable, requestOptions, listOptions);
List <LineItemDetailData> lineItemData = lineItemDataResponse.Items;
listOptions.ContinuationToken = lineItemDataResponse.Meta.ContinuationToken;
while (listOptions.ContinuationToken != null)
{
CosmosListPage <LineItemDetailData> responseWithToken = await _lineItemDetail.GetItemsAsync(queryable, requestOptions, listOptions);
lineItemData.AddRange(responseWithToken.Items);
listOptions.ContinuationToken = responseWithToken.Meta.ContinuationToken;
}
var lineItems = new List <HSLineItemOrder>();
foreach (LineItemDetailData detailData in lineItemData)
{
foreach (HSLineItem lineDetail in detailData.Data.LineItems)
{
lineItems.Add(new HSLineItemOrder
{
HSOrder = detailData.Data.Order,
HSLineItem = lineDetail
});
}
}
return(lineItems);
}
public async Task <CosmosListPage <RMA> > ListBuyerRMAs(CosmosListOptions listOptions, VerifiedUserContext verifiedUser)
{
IQueryable <RMA> queryable = _rmaRepo.GetQueryable().Where(rma => rma.FromBuyerID == verifiedUser.Buyer.ID);
CosmosListPage <RMA> rmas = await GenerateRMAList(queryable, listOptions);
return(rmas);
}
public async Task <CosmosListPage <RMA> > ListBuyerRMAs(CosmosListOptions listOptions, string buyerID)
{
IQueryable <RMA> queryable = _rmaRepo.GetQueryable().Where(rma => rma.FromBuyerID == buyerID);
CosmosListPage <RMA> rmas = await GenerateRMAList(queryable, listOptions);
return(rmas);
}
public async Task <List <OrderWithShipments> > ShipmentDetail(string templateID, ListArgs <ReportAdHocFilters> args, DecodedToken decodedToken)
{
IList <ListFilter> filters = await BuildFilters(templateID, args, decodedToken, "DateSubmitted", "SupplierID");
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = -1,
Sort = "OrderID",
SortDirection = SortDirection.ASC,
Filters = filters,
};
IQueryable <OrderWithShipments> queryable = _ordersAndShipments.GetQueryable()
.Where(order =>
order.PartitionKey == "PartitionValue");
QueryRequestOptions requestOptions = new QueryRequestOptions
{
MaxItemCount = listOptions.PageSize,
MaxConcurrency = -1
};
CosmosListPage <OrderWithShipments> ordersWithShipmentsDataResponse = await _ordersAndShipments.GetItemsAsync(queryable, requestOptions, listOptions);
List <OrderWithShipments> orderWithShipmentsData = ordersWithShipmentsDataResponse.Items;
listOptions.ContinuationToken = ordersWithShipmentsDataResponse.Meta.ContinuationToken;
while (listOptions.ContinuationToken != null)
{
CosmosListPage <OrderWithShipments> responseWithToken = await _ordersAndShipments.GetItemsAsync(queryable, requestOptions, listOptions);
orderWithShipmentsData.AddRange(responseWithToken.Items);
listOptions.ContinuationToken = responseWithToken.Meta.ContinuationToken;
}
var ordersWithShipments = new List <OrderWithShipments>();
var supplierFilter = args.Filters.FirstOrDefault(filter => filter.PropertyName == "SupplierID");
var me = await _oc.Me.GetAsync(decodedToken.AccessToken);
foreach (OrderWithShipments detailData in orderWithShipmentsData)
{
if (supplierFilter == null || supplierFilter.FilterExpression == detailData.SupplierID)
{
if (decodedToken.CommerceRole == CommerceRole.Seller || me.Supplier.ID == detailData.SupplierID)
{
ordersWithShipments.Add(detailData);
}
}
}
return(ordersWithShipments);
}
private async Task <RMA> GetRMA(string rmaNumber, DecodedToken decodedToken)
{
var currentRMAFilter = new ListFilter("RMANumber", rmaNumber);
CosmosListOptions currentRMAListOptions = new CosmosListOptions()
{
PageSize = 1, ContinuationToken = null, Filters = { currentRMAFilter }
};
CosmosListPage <RMA> currentRMAListPage = await ListRMAs(currentRMAListOptions, decodedToken);
RMA currentRMA = currentRMAListPage.Items[0];
return(currentRMA);
}
public async Task <CosmosListPage <RMA> > ListRMAs(CosmosListOptions listOptions, DecodedToken decodedToken)
{
IQueryable <RMA> queryable = _rmaRepo.GetQueryable().Where(rma => rma.PartitionKey == "PartitionValue");
if (decodedToken.CommerceRole == CommerceRole.Supplier)
{
var me = await _oc.Me.GetAsync(accessToken : decodedToken.AccessToken);
queryable = queryable.Where(rma => rma.SupplierID == me.Supplier.ID);
}
CosmosListPage <RMA> rmas = await GenerateRMAList(queryable, listOptions);
return(rmas);
}
public async Task <List <OrderDetailData> > PurchaseOrderDetail(string templateID, ListArgs <ReportAdHocFilters> args, DecodedToken decodedToken)
{
IList <ListFilter> filters = await BuildFilters(templateID, args, decodedToken, "DateSubmitted", "xp.SupplierIDs", "ShippingAddressID");
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = -1,
Sort = "OrderID",
SortDirection = SortDirection.ASC,
Filters = filters,
};
IQueryable <OrderDetailData> queryable = _purchaseOrderDetail.GetQueryable()
.Where(order =>
order.PartitionKey == "PartitionValue");
QueryRequestOptions requestOptions = new QueryRequestOptions
{
MaxItemCount = listOptions.PageSize,
MaxConcurrency = -1
};
CosmosListPage <OrderDetailData> purchaseOrderDataResponse = await _purchaseOrderDetail.GetItemsAsync(queryable, requestOptions, listOptions);
List <OrderDetailData> purchaseOrderData = purchaseOrderDataResponse.Items;
listOptions.ContinuationToken = purchaseOrderDataResponse.Meta.ContinuationToken;
while (listOptions.ContinuationToken != null)
{
CosmosListPage <OrderDetailData> responseWithToken = await _purchaseOrderDetail.GetItemsAsync(queryable, requestOptions, listOptions);
purchaseOrderData.AddRange(responseWithToken.Items);
listOptions.ContinuationToken = responseWithToken.Meta.ContinuationToken;
}
var purchaseOrders = new List <OrderDetailData>();
foreach (OrderDetailData purchaseOrder in purchaseOrderData)
{
purchaseOrder.ShipFromAddressID = purchaseOrder.Data.xp.SelectedShipMethodsSupplierView != null ? purchaseOrder.Data.xp.SelectedShipMethodsSupplierView[0].ShipFromAddressID : null;
purchaseOrder.ShipMethod = purchaseOrder.Data.xp.SelectedShipMethodsSupplierView != null ? purchaseOrder.Data.xp.SelectedShipMethodsSupplierView[0].Name : null;
purchaseOrders.Add(purchaseOrder);
}
return(purchaseOrders);
}
public async Task <List <OrderDetailData> > SalesOrderDetail(string templateID, ListArgs <ReportAdHocFilters> args, DecodedToken decodedToken)
{
IList <ListFilter> filters = await BuildFilters(templateID, args, decodedToken, "DateSubmitted", "xp.SupplierIDs", "FromCompanyID");
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = -1,
Sort = "OrderID",
SortDirection = SortDirection.ASC,
Filters = filters,
};
IQueryable <OrderDetailData> queryable = _salesOrderDetail.GetQueryable()
.Where(order =>
order.PartitionKey == "PartitionValue");
QueryRequestOptions requestOptions = new QueryRequestOptions
{
MaxItemCount = listOptions.PageSize,
MaxConcurrency = -1
};
CosmosListPage <OrderDetailData> salesOrderDataResponse = await _salesOrderDetail.GetItemsAsync(queryable, requestOptions, listOptions);
List <OrderDetailData> salesOrderData = salesOrderDataResponse.Items;
listOptions.ContinuationToken = salesOrderDataResponse.Meta.ContinuationToken;
while (listOptions.ContinuationToken != null)
{
CosmosListPage <OrderDetailData> responseWithToken = await _salesOrderDetail.GetItemsAsync(queryable, requestOptions, listOptions);
salesOrderData.AddRange(responseWithToken.Items);
listOptions.ContinuationToken = responseWithToken.Meta.ContinuationToken;
}
var salesOrders = new List <OrderDetailData>();
foreach (OrderDetailData salesOrder in salesOrderData)
{
salesOrders.Add(salesOrder);
}
return(salesOrders);
}
public async Task <CosmosListPage <RMA> > ListRMAsForOrder(string orderID, DecodedToken decodedToken)
{
var me = await _oc.Me.GetAsync(accessToken : decodedToken.AccessToken);
HSOrder order = await _oc.Orders.GetAsync <HSOrder>(OrderDirection.Incoming, orderID);
await EnsureUserCanAccessOrder(order, decodedToken);
var listFilter = new ListFilter("SourceOrderID", orderID);
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = 100, ContinuationToken = null, Filters = { listFilter }
};
CosmosListPage <RMA> rmasOnOrder = await _rmaCommand.ListBuyerRMAs(listOptions, me.Buyer.ID);
return(rmasOnOrder);
}
private async Task <CosmosListPage <LineItemDetailData> > GetLineItemDataAsync(string productID)
{
var queryable = _lineItemDetailDataRepo
.GetQueryable()
.Where(order => order.Data.LineItems.Any(lineItem => lineItem.ProductID == productID) && order.Data.Order.DateCreated > DateTime.Now.AddMonths(-12));
var requestOptions = new QueryRequestOptions()
{
MaxItemCount = 1
};
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = 100, ContinuationToken = null
};
CosmosListPage <LineItemDetailData> currentLineItemListPage = await _lineItemDetailDataRepo.GetItemsAsync(queryable, requestOptions, listOptions);
return(currentLineItemListPage);
}
private async Task <string> BuildRMANumber(HSOrder order)
{
var args = new CosmosListOptions()
{
PageSize = 100,
Filters = new List <ListFilter>()
{
new ListFilter("SourceOrderID", order.ID)
}
};
CosmosListPage <RMA> existingRMAsOnOrder = await ListBuyerRMAs(args, order.FromCompanyID);
int lastRMANumber = existingRMAsOnOrder.Items
.OrderBy(rma => rma.RMANumber)
.Select(rma => int.Parse(rma.RMANumber.Substring(rma.RMANumber.LastIndexOf("-") + 1)))
.LastOrDefault();
string rmaSuffix = $"{lastRMANumber + 1}".PadLeft(2, '0');
string rmaNumber = $"{order.ID}-RMA-{rmaSuffix}";
return(rmaNumber);
}
public virtual async Task <CosmosListPage <RMA> > ListRMAsByOrderID(string orderID, CommerceRole commerceRole, MeUser me, bool accessAllRMAsOnOrder = false)
{
string sourceOrderID = orderID.Split("-")[0];
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = 100
};
IQueryable <RMA> queryable = _rmaRepo.GetQueryable()
.Where(rma =>
rma.PartitionKey == "PartitionValue" &&
rma.SourceOrderID == sourceOrderID);
if (commerceRole == CommerceRole.Supplier && !accessAllRMAsOnOrder)
{
queryable = QueryOnlySupplierRMAs(queryable, me.Supplier.ID);
}
CosmosListPage <RMA> rmas = await GenerateRMAList(queryable, listOptions);
return(rmas);
}
public async Task <RMA> Get(ListArgs <RMA> args, DecodedToken decodedToken)
{
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = 100,
Search = args.Search,
SearchOn = "RMANumber"
};
IQueryable <RMA> queryable = _rmaRepo.GetQueryable()
.Where(rma =>
rma.PartitionKey == "PartitionValue");
if (decodedToken.CommerceRole == CommerceRole.Supplier)
{
var me = await _oc.Me.GetAsync(accessToken : decodedToken.AccessToken);
queryable = queryable.Where(rma => rma.SupplierID == me.Supplier.ID);
}
CosmosListPage <RMA> rmas = await GenerateRMAList(queryable, listOptions);
return(rmas.Items[0]);
}
public async Task <CosmosListPage <RMA> > ListRMAs([FromBody] CosmosListOptions listOptions)
{
return(await _rmaCommand.ListRMAs(listOptions, UserContext));
}
public async Task <CosmosListPage <RMA> > ListBuyerRMAs([FromBody] CosmosListOptions listOptions)
{
var me = await _oc.Me.GetAsync(accessToken : UserContext.AccessToken);
return(await _rmaCommand.ListBuyerRMAs(listOptions, me?.Buyer?.ID));
}
public async Task <CosmosListPage <RMA> > ListBuyerRMAs([FromBody] CosmosListOptions listOptions)
{
RequireOneOf(CustomRole.MPLocationViewAllOrders);
return(await _rmaCommand.ListBuyerRMAs(listOptions, VerifiedUserContext));
}
public async Task <List <HSLineItemOrder> > LineItemDetail(string templateID, ListArgs <ReportAdHocFilters> args, DecodedToken decodedToken)
{
IList <ListFilter> filters = await BuildFilters(templateID, args, decodedToken, "DateSubmitted", "xp.SupplierIDs", "FromCompanyID");
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = -1,
Sort = "OrderID",
SortDirection = SortDirection.ASC,
Filters = filters,
};
IQueryable <LineItemDetailData> queryable = _lineItemDetail.GetQueryable()
.Where(order =>
order.PartitionKey == "PartitionValue");
QueryRequestOptions requestOptions = new QueryRequestOptions
{
MaxItemCount = listOptions.PageSize,
MaxConcurrency = -1
};
CosmosListPage <LineItemDetailData> lineItemDataResponse = await _lineItemDetail.GetItemsAsync(queryable, requestOptions, listOptions);
List <LineItemDetailData> lineItemData = lineItemDataResponse.Items;
listOptions.ContinuationToken = lineItemDataResponse.Meta.ContinuationToken;
while (listOptions.ContinuationToken != null)
{
CosmosListPage <LineItemDetailData> responseWithToken = await _lineItemDetail.GetItemsAsync(queryable, requestOptions, listOptions);
lineItemData.AddRange(responseWithToken.Items);
listOptions.ContinuationToken = responseWithToken.Meta.ContinuationToken;
}
var lineItems = new List <HSLineItemOrder>();
var supplierFilter = args.Filters.FirstOrDefault(filter => filter.PropertyName == "SupplierID");
var me = await _oc.Me.GetAsync(decodedToken.AccessToken);
foreach (LineItemDetailData detailData in lineItemData)
{
foreach (HSLineItem lineDetail in detailData.Data.LineItems)
{
if (supplierFilter == null || supplierFilter.FilterExpression == lineDetail.SupplierID)
{
if (decodedToken.CommerceRole == CommerceRole.Supplier)
{
//filter down to only current supplierID
var lineWithPOOrderFields = detailData.Data.LineItemsWithPurchaseOrderFields != null?detailData.Data.LineItemsWithPurchaseOrderFields.FirstOrDefault(line => line.SupplierID == me.Supplier.ID && line.ID == lineDetail.ID) : null;
if (lineWithPOOrderFields != null)
{
lineDetail.ID = lineWithPOOrderFields.ID;
detailData.Data.Order.Subtotal = lineWithPOOrderFields.Subtotal;
detailData.Data.Order.ID = lineWithPOOrderFields.OrderID;
detailData.Data.Order.Total = lineWithPOOrderFields.Total;
lineDetail.UnitPrice = lineWithPOOrderFields.UnitPrice;
}
}
if (decodedToken.CommerceRole == CommerceRole.Seller || me.Supplier.ID == lineDetail.SupplierID)
{
var lineWithMiscFields = detailData.Data.LineItemsWithMiscFields != null?detailData.Data.LineItemsWithMiscFields.FirstOrDefault(line => line.ID == lineDetail.ID) : null;
lineItems.Add(new HSLineItemOrder
{
HSOrder = detailData.Data.Order,
HSLineItem = lineDetail
});
}
}
}
}
return(lineItems);
}
public async Task <List <RMAWithRMALineItem> > RMADetail(string templateID, ListArgs <ReportAdHocFilters> args, DecodedToken decodedToken)
{
IList <ListFilter> filters = await BuildFilters(templateID, args, decodedToken, "DateCreated", "SupplierID");
CosmosListOptions listOptions = new CosmosListOptions()
{
PageSize = -1,
Sort = "RMANumber",
SortDirection = SortDirection.ASC,
Filters = filters,
};
IQueryable <RMA> queryable = _rmaDetail.GetQueryable()
.Where(order =>
order.PartitionKey == "PartitionValue");
QueryRequestOptions requestOptions = new QueryRequestOptions
{
MaxItemCount = listOptions.PageSize,
MaxConcurrency = -1
};
CosmosListPage <RMA> rmaDataResponse = await _rmaDetail.GetItemsAsync(queryable, requestOptions, listOptions);
List <RMA> rmaData = rmaDataResponse.Items;
listOptions.ContinuationToken = rmaDataResponse.Meta.ContinuationToken;
while (listOptions.ContinuationToken != null)
{
CosmosListPage <RMA> responseWithToken = await _rmaDetail.GetItemsAsync(queryable, requestOptions, listOptions);
rmaData.AddRange(responseWithToken.Items);
listOptions.ContinuationToken = responseWithToken.Meta.ContinuationToken;
}
var rmas = new List <RMAWithRMALineItem>();
var supplierFilter = args.Filters.FirstOrDefault(filter => filter.PropertyName == "SupplierID");
var me = await _oc.Me.GetAsync(decodedToken.AccessToken);
foreach (RMA detailData in rmaData)
{
if (supplierFilter == null || supplierFilter.FilterExpression == detailData.SupplierID)
{
if (decodedToken.CommerceRole == CommerceRole.Seller || me.Supplier.ID == detailData.SupplierID)
{
foreach (RMALineItem rmaLineItem in detailData.LineItems)
{
rmas.Add(new RMAWithRMALineItem
{
RMA = detailData,
RMALineItem = rmaLineItem
});
}
}
}
}
return(rmas);
}
private async Task <CosmosListPage <RMA> > GenerateRMAList(IQueryable <RMA> queryable, CosmosListOptions listOptions)
{
QueryRequestOptions requestOptions = new QueryRequestOptions();
requestOptions.MaxItemCount = listOptions.PageSize;
CosmosListPage <RMA> rmas = await _rmaRepo.GetItemsAsync(queryable, requestOptions, listOptions);
return(rmas);
}
