private IResult <SalesOrder> GetSalesOrder(ISalesOrderKey salesOrderKey)
{
var orderKey = salesOrderKey.ToSalesOrderKey();
var salesOrder = _salesUnitOfWork.SalesOrderRepository.FindByKey(orderKey,
o => o.SalesOrderPickedItems.Select(i => i.PickedInventoryItem),
o => o.SalesOrderItems.Select(i => i.ContractItem),
o => o.SalesOrderItems.Select(i => i.InventoryPickOrderItem));
if (salesOrder == null)
{
return(new InvalidResult <SalesOrder>(null, string.Format(UserMessages.SalesOrderNotFound, salesOrderKey)));
}
if (salesOrder.OrderStatus == SalesOrderStatus.Invoiced)
{
return(new InvalidResult <SalesOrder>(null, string.Format(UserMessages.CannotPickInvoicedCustomerOrder, salesOrderKey)));
}
salesOrder.InventoryShipmentOrder = _salesUnitOfWork.InventoryShipmentOrderRepository.FindByKey(salesOrder.ToInventoryShipmentOrderKey(),
i => i.PickedInventory.Items.Select(n => n.CurrentLocation),
i => i.SourceFacility.Locations,
i => i.DestinationFacility.Locations);
if (salesOrder.InventoryShipmentOrder.OrderStatus == OrderStatus.Void)
{
return(new InvalidResult <SalesOrder>(null, string.Format(UserMessages.CannotPickVoidedCustomerOrder, salesOrderKey)));
}
return(new SuccessResult <SalesOrder>(salesOrder));
}
internal IResult Execute(ISalesOrderKey key, out int?orderNum)
{
orderNum = null;
var orderKey = key.ToSalesOrderKey();
var order = UnitOfWork.SalesOrderRepository.FindByKey(orderKey,
c => c.InventoryShipmentOrder.ShipmentInformation,
c => c.LotAllowances,
c => c.SalesOrderItems,
c => c.SalesOrderPickedItems,
c => c.InventoryShipmentOrder.PickedInventory.Items.Select(i => i.CurrentLocation));
if (order == null)
{
return(new InvalidResult(string.Format(UserMessages.SalesOrderNotFound, orderKey)));
}
if (order.InventoryShipmentOrder.ShipmentInformation.Status == ShipmentStatus.Shipped)
{
return(new InvalidResult(string.Format(UserMessages.CannotDeleteShippedShipmentOrder)));
}
var removePickedItemsResult = UpdatePickedInventory(null, null, DateTime.UtcNow, order.InventoryShipmentOrder.PickedInventory, null);
if (!removePickedItemsResult.Success)
{
return(removePickedItemsResult);
}
orderNum = order.InventoryShipmentOrder.MoveNum;
UnitOfWork.SalesOrderRepository.Remove(order);
return(new SuccessResult());
}
internal static SalesOrderItem ConstrainByKeys(this SalesOrderItem item, ISalesOrderKey order = null, IContractItemKey contractItem = null, IChileProductKey chileProduct = null, IPackagingProductKey packagingProduct = null, IInventoryTreatmentKey treatment = null)
{
if (item == null)
{
throw new ArgumentNullException("item");
}
if (order != null)
{
item.Order = null;
item.DateCreated = order.SalesOrderKey_DateCreated;
item.Sequence = order.SalesOrderKey_Sequence;
if (item.InventoryPickOrderItem != null)
{
item.InventoryPickOrderItem.InventoryPickOrder = null;
}
}
if (contractItem != null)
{
item.ContractItem = null;
item.ContractYear = contractItem.ContractKey_Year;
item.ContractSequence = contractItem.ContractKey_Sequence;
item.ContractItemSequence = contractItem.ContractItemKey_Sequence;
}
if (chileProduct != null)
{
item.InventoryPickOrderItem.Product = null;
item.InventoryPickOrderItem.ProductId = chileProduct.ChileProductKey_ProductId;
}
if (packagingProduct != null)
{
item.InventoryPickOrderItem.PackagingProduct = null;
item.InventoryPickOrderItem.PackagingProductId = packagingProduct.PackagingProductKey_ProductId;
}
if (treatment != null)
{
item.InventoryPickOrderItem.InventoryTreatment = null;
item.InventoryPickOrderItem.TreatmentId = treatment.InventoryTreatmentKey_Id;
}
return(item);
}
internal static Lot AddOrderAllowance(this Lot lot, ISalesOrderKey order)
{
if (lot.SalesOrderAllowances == null)
{
lot.SalesOrderAllowances = new List <LotSalesOrderAllowance>();
}
lot.SalesOrderAllowances.Add(new LotSalesOrderAllowance
{
LotTypeId = lot.LotTypeId,
LotDateCreated = lot.LotDateCreated,
LotDateSequence = lot.LotDateSequence,
SalesOrderDateCreated = order.SalesOrderKey_DateCreated,
SalesOrderSequence = order.SalesOrderKey_Sequence
});
return(lot);
}
internal IResult <ISalesOrderInvoice> Get(ISalesOrderKey orderKey)
{
var customerOrderKey = orderKey.ToSalesOrderKey();
var predicate = customerOrderKey.FindByPredicate;
var select = SalesOrderProjectors.SelectCustomerOrderInvoice();
var invoice = _inventoryShipmentOrderUnitOfWork.SalesOrderRepository
.Filter(predicate)
.AsExpandable()
.Select(select)
.FirstOrDefault();
if (invoice == null)
{
return(new InvalidResult <ISalesOrderInvoice>(null, string.Format(UserMessages.SalesOrderNotFound, customerOrderKey)));
}
invoice.Initialize();
return(new SuccessResult <ISalesOrderInvoice>(invoice));
}
public PickingValidatorContext(IDictionary <AttributeNameKey, ChileProductAttributeRange> productSpec,
IDictionary <AttributeNameKey, CustomerProductAttributeRange> customerSpec,
IContractKey contractKey, ISalesOrderKey salesOrderKey, ICustomerKey customerKey)
{
if (contractKey != null)
{
ContractKey = contractKey.ToContractKey();
}
if (salesOrderKey != null)
{
CustomerOrderKey = salesOrderKey.ToSalesOrderKey();
}
if (customerKey != null)
{
CustomerKey = customerKey.ToCustomerKey();
}
var productSpecRanges = productSpec == null ? new Dictionary <string, IAttributeRange>() : productSpec.To().Dictionary <string, IAttributeRange>(p => p.Key, p => p.Value);
var customerSpecRanges = customerSpec == null ? new Dictionary <string, IAttributeRange>() : customerSpec.To().Dictionary <string, IAttributeRange>(p => p.Key, p => p.Value);
foreach (var prodSpec in productSpecRanges)
{
IAttributeRange custRange;
if (customerSpecRanges.TryGetValue(prodSpec.Key, out custRange))
{
customerSpecRanges.Remove(prodSpec.Key);
}
AttributeSpecs.Add(prodSpec.Key, new PickingValidatorAttributeSpec(prodSpec.Value, custRange));
}
foreach (var custSpec in customerSpecRanges)
{
AttributeSpecs.Add(custSpec.Key, new PickingValidatorAttributeSpec(null, custSpec.Value));
}
}
internal static SalesOrderPickedItem ConstrainByKeys(this SalesOrderPickedItem pickedItem, ISalesOrderKey salesOrderKey)
{
if (pickedItem == null)
{
throw new ArgumentNullException("pickedItem");
}
if (salesOrderKey == null)
{
throw new ArgumentNullException("salesOrderKey");
}
pickedItem.SalesOrder = null;
pickedItem.DateCreated = salesOrderKey.SalesOrderKey_DateCreated;
pickedItem.Sequence = salesOrderKey.SalesOrderKey_Sequence;
if (pickedItem.PickedInventoryItem != null)
{
pickedItem.PickedInventoryItem.PickedInventory = null;
}
if (pickedItem.SalesOrderItem != null)
{
pickedItem.SalesOrderItem.ConstrainByKeys(salesOrderKey);
}
return(pickedItem);
}
internal static Expression <Func <LotSalesOrderAllowance, bool> > ByCustomerOrderKey(ISalesOrderKey key)
{
return(a => a.SalesOrderDateCreated == key.SalesOrderKey_DateCreated && a.SalesOrderSequence == key.SalesOrderKey_Sequence);
}
internal static Expression <Func <Inventory, bool> > ByAllowance(ICustomerKey customer, ISalesOrderKey salesOrder, IContractKey contract)
{
var predicate = PredicateBuilder.False <Inventory>();
if (contract != null)
{
var contractPredicate = LotContractAllowancePredicates.ByContractKey(contract);
predicate = predicate.Or(i => i.Lot.ContractAllowances.Any(a => contractPredicate.Invoke(a)));
}
if (salesOrder != null)
{
var customerOrderPredicate = LotCustomerOrderAllowancePredicates.ByCustomerOrderKey(salesOrder);
predicate = predicate.Or(i => i.Lot.SalesOrderAllowances.Any(a => customerOrderPredicate.Invoke(a)));
}
if (customer != null)
{
var customerPredicate = LotCustomerAllowancePredicates.ByCustomerKey(customer);
predicate = predicate.Or(i => i.Lot.CustomerAllowances.Any(a => customerPredicate.Invoke(a)));
}
return(predicate);
}
internal IResult <SalesOrder> Execute(DateTime timestamp, ISalesOrderKey salesOrderKey, ISetPickedInventoryParameters setPickedInventory)
{
if (salesOrderKey == null)
{
throw new ArgumentNullException("salesOrderKey");
}
if (setPickedInventory == null)
{
throw new ArgumentNullException("setPickedInventory");
}
var employeeResult = new GetEmployeeCommand(_salesUnitOfWork).GetEmployee(setPickedInventory);
if (!employeeResult.Success)
{
return(employeeResult.ConvertTo <SalesOrder>());
}
var customerOrderResult = GetSalesOrder(salesOrderKey);
if (!customerOrderResult.Success)
{
return(customerOrderResult);
}
var salesOrder = customerOrderResult.ResultingObject;
salesOrder.InventoryShipmentOrder.PickedInventory.EmployeeId = employeeResult.ResultingObject.EmployeeId;
salesOrder.InventoryShipmentOrder.PickedInventory.TimeStamp = timestamp;
var parsedPickedInventory = new List <PickedInventoryParameters>();
foreach (var item in setPickedInventory.PickedInventoryItems)
{
var itemParseResult = item.ToParsedParameters(true);
if (!itemParseResult.Success)
{
return(itemParseResult.ConvertTo <SalesOrder>());
}
parsedPickedInventory.Add(itemParseResult.ResultingObject);
}
var pickedInventoryModifications = PickedInventoryHelper.CreateModifyCustomerOrderPickedInventoryItemParameters(salesOrder, parsedPickedInventory);
var validatorResult = ValidateModifyPickedInventoryItems(salesOrder, pickedInventoryModifications);
if (!validatorResult.Success)
{
return(validatorResult.ConvertTo <SalesOrder>());
}
var modifyPickedResult = new ModifySalesOrderPickedItemsCommand(_salesUnitOfWork).Execute(new PickedInventoryKey(salesOrder.InventoryShipmentOrder), pickedInventoryModifications);
if (!modifyPickedResult.Success)
{
return(modifyPickedResult.ConvertTo <SalesOrder>());
}
var inventoryModifications = pickedInventoryModifications.Select(p => p.ToModifySourceInventoryParameters());
var modifyInventoryResult = new ModifyInventoryCommand(_salesUnitOfWork).Execute(inventoryModifications, null);
if (!modifyInventoryResult.Success)
{
return(modifyInventoryResult.ConvertTo <SalesOrder>());
}
return(new SuccessResult <SalesOrder>(salesOrder));
}
public static SalesOrderKey ToSalesOrderKey(this ISalesOrderKey k)
{
return(new SalesOrderKey(k));
}
