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));
}
internal static Expression <Func <TreatmentOrder, bool> > ByInventoryShipmentOrder(IInventoryShipmentOrderKey inventoryShipmentOrderKey)
{
var predicate = new InventoryShipmentOrderKey(inventoryShipmentOrderKey).FindByPredicate;
Expression <Func <TreatmentOrder, bool> > expression = i => predicate.Invoke(i.InventoryShipmentOrder);
return(expression.Expand());
}
public void Sets_ShipmentInformation_as_expected()
{
//Arrange
var orderKey = new InventoryShipmentOrderKey(TestHelper.CreateObjectGraphAndInsertIntoDatabase <TreatmentOrder>());
var parameters = new SetInventoryShipmentInformationParameters
{
InventoryShipmentOrderKey = orderKey,
ShippingInstructions = new SetShippingInstructionsParameters
{
ExternalNotes = "In Russia, comments write *you*."
}
};
//Act
var result = Service.SetShipmentInformation(parameters);
//Assert
result.AssertSuccess();
Assert.AreEqual(parameters.ShippingInstructions.ExternalNotes, RVCUnitOfWork.InventoryShipmentOrderRepository.FindByKey(orderKey, o => o.ShipmentInformation).ShipmentInformation.ExternalNotes);
}
public IResult <IInventoryShipmentOrderBillOfLadingReturn> GetInventoryShipmentOrderBillOfLading(string orderKey)
{
var orderKeyResult = KeyParserHelper.ParseResult <IInventoryShipmentOrderKey>(orderKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult.ConvertTo <IInventoryShipmentOrderBillOfLadingReturn>());
}
var predicate = new InventoryShipmentOrderKey(orderKeyResult.ResultingObject).FindByPredicate;
var select = InventoryShipmentOrderProjectors.SplitSelectBillOfLading();
var order = _inventoryShipmentOrderUnitOfWork.InventoryShipmentOrderRepository.Filter(predicate).SplitSelect(select).FirstOrDefault();
if (order == null)
{
return(new InvalidResult <IInventoryShipmentOrderBillOfLadingReturn>(null, string.Format(UserMessages.InventoryShipmentOrderNotFound, orderKey)));
}
return(new SuccessResult <IInventoryShipmentOrderBillOfLadingReturn>(order));
}
private IResult <InventoryShipmentOrder> GetOrder(InventoryShipmentOrderKey orderKey)
{
var inventoryShipmentOrder = _inventoryShipmentUnitOfWork.InventoryShipmentOrderRepository.FindByKey(orderKey,
i => i.ShipmentInformation,
i => i.SourceFacility,
i => i.PickedInventory.Items.Select(t => t.FromLocation),
i => i.PickedInventory.Items.Select(t => t.CurrentLocation),
i => i.InventoryPickOrder.Items.Select(t => t.Product),
i => i.InventoryPickOrder.Items.Select(t => t.Customer));
if (inventoryShipmentOrder == null)
{
return(new InvalidResult <InventoryShipmentOrder>(null, string.Format(UserMessages.InventoryShipmentOrderNotFound, orderKey)));
}
if (inventoryShipmentOrder.ShipmentInformation.Status != ShipmentStatus.Scheduled && inventoryShipmentOrder.ShipmentInformation.Status != ShipmentStatus.Unscheduled)
{
return(new InvalidResult <InventoryShipmentOrder>(null, string.Format(UserMessages.CannotPickShipment, inventoryShipmentOrder.ShipmentInformation.Status)));
}
return(new SuccessResult <InventoryShipmentOrder>(inventoryShipmentOrder));
}
public UpdateInterWarehouseOrderConductorParameters(TParams parameters) : base(parameters)
{
if (Result.Success)
{
var keyResult = KeyParserHelper.ParseResult <IInventoryShipmentOrderKey>(parameters.InventoryShipmentOrderKey);
if (!keyResult.Success)
{
Result = keyResult;
return;
}
InventoryShipmentOrderKey = new InventoryShipmentOrderKey(keyResult.ResultingObject);
var setItemCodesResult = ParseParameters(parameters.PickedInventoryItemCodes);
if (!setItemCodesResult.Success)
{
Result = setItemCodesResult;
return;
}
SetPickedInventoryItemCodes = setItemCodesResult.ResultingObject;
}
}
public IResult SetShipmentInformation(ISetInventoryShipmentInformationParameters parameters)
{
var parametersResult = parameters.ToParsedParameters();
if (!parametersResult.Success)
{
return(parametersResult);
}
var result = new SetShipmentInformationConductor(_inventoryShipmentOrderUnitOfWork).SetShipmentInformation(parametersResult.ResultingObject);
if (!result.Success)
{
return(result);
}
_inventoryShipmentOrderUnitOfWork.Commit();
var key = new InventoryShipmentOrderKey(result.ResultingObject);
return(SyncParameters.Using(new SuccessResult <string>(key), key));
}
internal IResult UpdatePickedInventory(InventoryShipmentOrderKey orderKey, IUserIdentifiable user, DateTime timestamp, List <PickedInventoryParameters> setPickedInventoryItems)
{
var employeeResult = new GetEmployeeCommand(_inventoryShipmentUnitOfWork).GetEmployee(user);
if (!employeeResult.Success)
{
return(employeeResult.ConvertTo <InventoryShipmentOrder>());
}
var orderResult = GetOrder(orderKey);
if (!orderResult.Success)
{
return(orderResult);
}
orderResult.ResultingObject.PickedInventory.EmployeeId = employeeResult.ResultingObject.EmployeeId;
orderResult.ResultingObject.PickedInventory.TimeStamp = timestamp;
var pickedInventoryModifications = PickedInventoryHelper.CreateModifyPickedInventoryItemParameters(orderResult.ResultingObject.PickedInventory, setPickedInventoryItems);
var validatorResult = ValidateModifyPickedInventoryItems(orderResult.ResultingObject, pickedInventoryModifications);
if (!validatorResult.Success)
{
return(validatorResult.ConvertTo <SalesOrder>());
}
var modifyPickedResult = new ModifyPickedInventoryItemsCommand(_inventoryShipmentUnitOfWork).Execute(orderResult.ResultingObject.PickedInventory, pickedInventoryModifications);
if (!modifyPickedResult.Success)
{
return(modifyPickedResult);
}
return(new ModifyInventoryCommand(_inventoryShipmentUnitOfWork).Execute(pickedInventoryModifications.Select(p => p.ToModifySourceInventoryParameters()).ToList(), null));
}
internal static IResult <InventoryPredicateBuilder.PredicateBuilderFilters> ParseToPredicateBuilderFilters(this FilterInventoryForShipmentOrderParameters parameters,
out InventoryShipmentOrderKey orderKey, out InventoryPickOrderItemKey orderItemKey)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
orderKey = null;
orderItemKey = null;
if (!string.IsNullOrWhiteSpace(parameters.OrderKey))
{
var orderKeyResult = KeyParserHelper.ParseResult <IInventoryShipmentOrderKey>(parameters.OrderKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
}
orderKey = orderKeyResult.ResultingObject.ToInventoryShipmentOrderKey();
}
if (!string.IsNullOrWhiteSpace(parameters.OrderItemKey))
{
var orderItemKeyResult = KeyParserHelper.ParseResult <IInventoryPickOrderItemKey>(parameters.OrderItemKey);
if (!orderItemKeyResult.Success)
{
return(orderItemKeyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
}
orderItemKey = orderItemKeyResult.ResultingObject.ToInventoryPickOrderItemKey();
}
var baseResult = parameters.ParseToPredicateBuilderFilters();
if (baseResult.Success)
{
var filters = baseResult.ResultingObject;
return(new SuccessResult <InventoryPredicateBuilder.PredicateBuilderFilters>(filters));
}
return(baseResult);
}
