public IResult <IInventoryShipmentOrderCertificateOfAnalysisReturn> GetInventoryShipmentOrderCertificateOfAnalysis(string orderKey)
{
var orderKeyResult = KeyParserHelper.ParseResult <IInventoryShipmentOrderKey>(orderKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult.ConvertTo <IInventoryShipmentOrderCertificateOfAnalysisReturn>());
}
var predicate = orderKeyResult.ResultingObject.ToInventoryShipmentOrderKey().FindByPredicate;
var select = InventoryShipmentOrderProjectors.SplitSelectCertificateOfAnalysisReturn();
var order = _inventoryShipmentOrderUnitOfWork.InventoryShipmentOrderRepository.Filter(predicate).SplitSelect(select).FirstOrDefault();
if (order == null)
{
return(new InvalidResult <IInventoryShipmentOrderCertificateOfAnalysisReturn>(null, string.Format(UserMessages.InventoryShipmentOrderNotFound, orderKey)));
}
if (order.OrderType == InventoryShipmentOrderTypeEnum.SalesOrder)
{
var customerOrderKey = new SalesOrderKey(orderKeyResult.ResultingObject);
var customerOrder = _inventoryShipmentOrderUnitOfWork.SalesOrderRepository.FindByKey(customerOrderKey,
o => o.Customer.Company);
if (customerOrder == null)
{
return(new InvalidResult <IInventoryShipmentOrderCertificateOfAnalysisReturn>(null, string.Format(UserMessages.SalesOrderNotFound, customerOrderKey)));
}
order.DestinationName = customerOrder.Customer == null ? null : customerOrder.Customer.Company.Name;
}
return(new SuccessResult <IInventoryShipmentOrderCertificateOfAnalysisReturn>(order));
}
public IResult <IInventoryShipmentOrderPickSheetReturn> GetInventoryShipmentOrderPickSheet(string orderKey)
{
var orderKeyResult = KeyParserHelper.ParseResult <IInventoryShipmentOrderKey>(orderKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult.ConvertTo <IInventoryShipmentOrderPickSheetReturn>());
}
var predicate = new InventoryShipmentOrderKey(orderKeyResult.ResultingObject).FindByPredicate;
var select = InventoryShipmentOrderProjectors.SplitSelectPickSheet().Merge();
var order = _inventoryShipmentOrderUnitOfWork.InventoryShipmentOrderRepository.Filter(predicate).Select(select).FirstOrDefault();
if (order == null)
{
return(new InvalidResult <IInventoryShipmentOrderPickSheetReturn>(null, string.Format(UserMessages.InventoryShipmentOrderNotFound, orderKey)));
}
if (order.OrderType == InventoryShipmentOrderTypeEnum.SalesOrder)
{
var customerOrderKey = new SalesOrderKey(orderKeyResult.ResultingObject);
var customerOrder = _inventoryShipmentOrderUnitOfWork.SalesOrderRepository.FindByKey(customerOrderKey);
if (customerOrder == null)
{
return(new InvalidResult <IInventoryShipmentOrderPickSheetReturn>(null, string.Format(UserMessages.SalesOrderNotFound, customerOrderKey)));
}
order.ShipFromOrSoldToShippingLabel = customerOrder.SoldTo;
}
return(new SuccessResult <IInventoryShipmentOrderPickSheetReturn>(order));
}
public IResult <IPickableInventoryReturn> GetInventoryToPickForOrder(FilterInventoryForShipmentOrderParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
InventoryShipmentOrderKey orderKey;
InventoryPickOrderItemKey orderItemKey;
var filterResults = parameters.ParseToPredicateBuilderFilters(out orderKey, out orderItemKey);
if (!filterResults.Success)
{
return(filterResults.ConvertTo <IPickableInventoryReturn>());
}
var salesOrderKey = new SalesOrderKey(orderKey);
var salesOrderItemKey = orderItemKey == null ? null : new SalesOrderItemKey(orderItemKey);
var salesOrder = _inventoryShipmentOrderUnitOfWork.SalesOrderRepository.FindByKey(salesOrderKey,
o => o.InventoryShipmentOrder.SourceFacility,
o => o.SalesOrderItems.Select(i => i.ContractItem),
o => o.SalesOrderItems.Select(i => i.InventoryPickOrderItem));
if (salesOrder == null)
{
return(new InvalidResult <IPickableInventoryReturn>(null, string.Format(UserMessages.SalesOrderNotFound, orderKey.KeyValue)));
}
IDictionary <AttributeNameKey, ChileProductAttributeRange> productSpec = null;
IDictionary <AttributeNameKey, CustomerProductAttributeRange> customerSpec = null;
SalesOrderItem orderItem = null;
if (salesOrderItemKey != null)
{
var item = salesOrder.SalesOrderItems.FirstOrDefault(salesOrderItemKey.FindByPredicate.Compile());
if (item == null)
{
return(new InvalidResult <IPickableInventoryReturn>(null, string.Format(UserMessages.SalesOrderItemNotFound, salesOrderItemKey)));
}
orderItem = item;
var specResult = new GetProductSpecCommand(_inventoryShipmentOrderUnitOfWork).Execute(ChileProductKey.FromProductKey(item.InventoryPickOrderItem),
item.Order, out productSpec, out customerSpec);
if (!specResult.Success)
{
return(specResult.ConvertTo <IPickableInventoryReturn>());
}
}
var itemsResult = new GetPickableInventoryCommand(_inventoryShipmentOrderUnitOfWork).Execute(filterResults.ResultingObject, _timeStamper.CurrentTimeStamp,
PickedInventoryValidator.ForSalesOrder(salesOrder.InventoryShipmentOrder.SourceFacility), true);
if (itemsResult.Success)
{
itemsResult.ResultingObject.Initializer = new ValidPickingForOrder(new PickingValidatorContext(productSpec, customerSpec, orderItem == null ? null : orderItem.ContractItem, salesOrder, salesOrder));
}
return(itemsResult);
}
private PickedInventoryKeyHelper(RioAccessSQLEntities oldContext)
{
var customerOrderKey = new SalesOrderKey();
foreach (var reservedKey in oldContext.tblOrders.Where(o => o.SerializedKey != null).Select(o => o.SerializedKey))
{
ISalesOrderKey parsedKey;
if (customerOrderKey.TryParse(reservedKey, out parsedKey))
{
GetRange(parsedKey.SalesOrderKey_DateCreated).RegisterSequence(parsedKey.SalesOrderKey_Sequence);
}
}
}
private SalesOrder GetSalesOrder(SalesOrderKey key)
{
var order = UnitOfWork.SalesOrderRepository.FindByKey(key,
c => c.Customer.Company,
c => c.Broker,
c => c.InventoryShipmentOrder.SourceFacility,
c => c.InventoryShipmentOrder.ShipmentInformation,
c => c.InventoryShipmentOrder.PickedInventory,
c => c.SalesOrderItems.Select(i => i.InventoryPickOrderItem.Product),
c => c.SalesOrderItems.Select(i => i.InventoryPickOrderItem.PackagingProduct.Product),
c => c.SalesOrderPickedItems.Select(p => p.PickedInventoryItem.CurrentLocation),
c => c.SalesOrderPickedItems.Select(p => p.PickedInventoryItem.PackagingProduct.Product),
c => c.SalesOrderPickedItems.Select(p => p.PickedInventoryItem.Lot.ChileLot.Production.Results),
c => c.SalesOrderPickedItems.Select(p => p.PickedInventoryItem.Lot.Attributes));
return(order);
}
public IResult <ISalesOrderAcknowledgementReturn> GetCustomerOrderAcknowledgement(string orderKey)
{
var orderKeyResult = KeyParserHelper.ParseResult <ISalesOrderKey>(orderKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult.ConvertTo <ISalesOrderAcknowledgementReturn>());
}
var predicate = new SalesOrderKey(orderKeyResult.ResultingObject).FindByPredicate;
var select = SalesOrderProjectors.SplitSelectAcknowledgement();
var order = _inventoryShipmentOrderUnitOfWork.SalesOrderRepository
.Filter(predicate)
.SplitSelect(select).FirstOrDefault();
if (order == null)
{
return(new InvalidResult <ISalesOrderAcknowledgementReturn>(null, string.Format(UserMessages.SalesOrderNotFound, orderKey)));
}
return(new SuccessResult <ISalesOrderAcknowledgementReturn>(order));
}
public void Modifies_tblOrderDetail_and_tblStagedFG_records_as_expected()
{
//Arrange
var customer = RVCUnitOfWork.CustomerRepository.Filter(c => true, c => c.Broker).FirstOrDefault();
var contractItem = RVCUnitOfWork.ContractItemRepository.All().FirstOrDefault(i => i.Contract.CustomerId == customer.Id);
var validInventory = RVCUnitOfWork.InventoryRepository.Filter(i =>
i.LotTypeId == (decimal)LotTypeEnum.FinishedGood &&
i.Lot.ProductionStatus == LotProductionStatus.Produced &&
i.Lot.QualityStatus == LotQualityStatus.Released,
i => i.Location)
.ToList();
if (!validInventory.Any())
{
Assert.Inconclusive("No valid test inventory found.");
}
var inventory = validInventory
.GroupBy(i => i.Location.FacilityId)
.First(g => g.Count() >= 2)
.OrderBy(i => i.LotDateCreated)
.Take(2)
.ToList();
var parameters = TestHelper.CreateObjectGraph <CreateSalesOrderParameters>();
parameters.UserToken = TestUser.UserName;
parameters.CustomerKey = customer.ToCustomerKey();
parameters.BrokerKey = customer.Broker.ToCompanyKey();
parameters.FacilitySourceKey = inventory[0].Location.ToFacilityKey();
parameters.OrderItems = new List <SalesOrderItemParameters>
{
new SalesOrderItemParameters
{
ContractItemKey = contractItem.ToContractItemKey(),
ProductKey = contractItem.ToChileProductKey(),
PackagingKey = contractItem.ToPackagingProductKey(),
TreatmentKey = contractItem.ToInventoryTreatmentKey(),
Quantity = 123,
CustomerLotCode = "OrderItem1",
PriceBase = 1,
PriceFreight = 2,
PriceTreatment = 3,
PriceWarehouse = 4,
PriceRebate = 5
},
new SalesOrderItemParameters
{
ContractItemKey = contractItem.ToContractItemKey(),
ProductKey = contractItem.ToChileProductKey(),
PackagingKey = contractItem.ToPackagingProductKey(),
TreatmentKey = contractItem.ToInventoryTreatmentKey(),
Quantity = 123,
CustomerLotCode = "OrderItem2",
PriceBase = 1,
PriceFreight = 2,
PriceTreatment = 3,
PriceWarehouse = 4,
PriceRebate = 5
},
};
//Act / Assert
//Create
var createResult = Service.CreateSalesOrder(parameters);
createResult.AssertSuccess();
MockKillSwitch.Verify(k => k.Engage(), Times.Never());
//Pick
var orderKey = new SalesOrderKey().Parse(createResult.ResultingObject).ToSalesOrderKey();
var order = RVCUnitOfWork.SalesOrderRepository.FindByKey(orderKey, o => o.SalesOrderItems);
var lotsToAllow = new List <LotKey>();
var itemsToPick = order.SalesOrderItems.Select(i =>
{
var result = Service.GetPickableInventoryForContext(new FilterInventoryForShipmentOrderParameters
{
OrderKey = i.ToSalesOrderKey(),
OrderItemKey = i.ToSalesOrderItemKey()
}).ResultingObject;
var pickable = result.Items.Where(n => n.Quantity > 1).Take(1).ToList();
lotsToAllow.AddRange(pickable.Cast <PickableInventoryItemReturn>().Select(p => p.LotKeyReturn.ToLotKey()));
return(new SetPickedInventoryItemParameters
{
InventoryKey = pickable.Select(r => r.InventoryKey).FirstOrDefault(),
Quantity = 1,
OrderItemKey = i.ToSalesOrderItemKey()
});
}
).ToList();
if (itemsToPick.Any(i => i.InventoryKey == null))
{
Assert.Inconclusive("Could not find valid Inventory to pick for CustomerOrderItem.");
}
lotsToAllow.Distinct().ForEach((l, n) =>
{
RVCUnitOfWork.LotSalesOrderAllowanceRepository.Add(new LotSalesOrderAllowance
{
SalesOrderDateCreated = orderKey.SalesOrderKey_DateCreated,
SalesOrderSequence = orderKey.SalesOrderKey_Sequence,
LotDateCreated = l.LotKey_DateCreated,
LotDateSequence = l.LotKey_DateSequence,
LotTypeId = l.LotKey_LotTypeId
});
});
RVCUnitOfWork.Commit();
var pickResult = Service.SetPickedInventory(orderKey, new SetPickedInventoryParameters
{
UserToken = TestUser.UserName,
PickedInventoryItems = itemsToPick
});
pickResult.AssertSuccess();
MockKillSwitch.Verify(k => k.Engage(), Times.Never());
var orderNumString = GetKeyFromConsoleString(ConsoleOutput.SyncTblOrder);
var orderNum = int.Parse(orderNumString);
using (var oldContext = new RioAccessSQLEntities())
{
var tblOrder = oldContext.tblOrders
.Include("tblOrderDetails.tblStagedFGs")
.FirstOrDefault(o => o.OrderNum == orderNum);
Assert.AreEqual(2, tblOrder.tblOrderDetails.Count);
foreach (var detail in tblOrder.tblOrderDetails)
{
Assert.AreEqual(1, detail.tblStagedFGs.Count);
}
}
//Unpick
pickResult = Service.SetPickedInventory(orderKey, new SetPickedInventoryParameters
{
UserToken = TestUser.UserName,
PickedInventoryItems = new List <IPickedInventoryItemParameters> {
itemsToPick[0]
}
});
pickResult.AssertSuccess();
MockKillSwitch.Verify(k => k.Engage(), Times.Never());
using (var oldContext = new RioAccessSQLEntities())
{
var tblOrder = oldContext.tblOrders
.Include("tblOrderDetails.tblStagedFGs")
.FirstOrDefault(o => o.OrderNum == orderNum);
Assert.AreEqual(2, tblOrder.tblOrderDetails.Count);
Assert.AreEqual(1, tblOrder.tblOrderDetails.Single(d => d.CustLot == "OrderItem1").tblStagedFGs.Count);
Assert.AreEqual(0, tblOrder.tblOrderDetails.Single(d => d.CustLot == "OrderItem2").tblStagedFGs.Count);
}
}
