public IResult <PickedInventory> Execute(ICreatePickedInventory parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var dateCreated = parameters.TimeStamp.Date;
var sequence = new EFUnitOfWorkHelper(_pickedInventoryUnitOfWork).GetNextSequence <PickedInventory>(i => i.DateCreated == dateCreated, i => i.Sequence);
var pickedInventory = new PickedInventory
{
EmployeeId = parameters.EmployeeKey.EmployeeKey_Id,
TimeStamp = parameters.TimeStamp,
DateCreated = dateCreated,
Sequence = sequence,
PickedReason = parameters.PickedReason,
Archived = false,
Items = new List <PickedInventoryItem>()
};
_pickedInventoryUnitOfWork.PickedInventoryRepository.Add(pickedInventory);
return(new SuccessResult <PickedInventory>(pickedInventory));
}
internal static PickedInventory EmptyItems(this PickedInventory pickedInventory)
{
if (pickedInventory == null)
{
throw new ArgumentNullException("pickedInventory");
}
pickedInventory.Items = null;
return(pickedInventory);
}
private PickedInventory CreatePickedInventory(DateTime entryDate, LotDTO lot)
{
_loadCount.AddRead(EntityTypes.PickedInventory);
var identifiable = lot.tblOutgoingInputs.Cast <IEmployeeIdentifiableDTO>().ToList();
identifiable.Add(lot);
int? employeeID;
DateTime?timeStamp;
identifiable.GetLatest(out employeeID, out timeStamp);
if (timeStamp == null)
{
Log(new CallbackParameters(CallbackReason.PickedInventoryUndeterminedTimestamp)
{
Lot = lot
});
return(null);
}
employeeID = employeeID ?? _newContextHelper.DefaultEmployee.EmployeeId;
if (employeeID == _newContextHelper.DefaultEmployee.EmployeeId)
{
Log(new CallbackParameters(CallbackReason.PickedInventoryUsedDefaultEmployee)
{
Lot = lot,
EmployeeId = employeeID.Value
});
}
var dateCreated = entryDate.Date;
var sequence = PickedInventoryKeyHelper.Singleton.GetNextSequence(dateCreated);
var pickedInventory = new PickedInventory
{
EmployeeId = employeeID.Value,
TimeStamp = timeStamp.Value,
DateCreated = dateCreated,
Sequence = sequence,
PickedReason = PickedReason.Production,
Archived = true,
};
pickedInventory.Items = CreatePickedInventoryItems(pickedInventory, lot.tblOutgoingInputs).ToList();
return(pickedInventory);
}
private PickedInventory CreateNewPickedInventory(ProductionBatchDTO batch)
{
_loadCount.AddRead(EntityTypes.PickedInventory);
var dateCreated = batch.BatchItems.Min(b => b.EntryDate.Date);
var sequence = PickedInventoryKeyHelper.Singleton.GetNextSequence(dateCreated);
var latest = batch.BatchItems.OrderByDescending(b => b.EntryDate).First();
var pickedInventory = new PickedInventory
{
DateCreated = dateCreated,
Sequence = sequence,
EmployeeId = latest.EmployeeID.Value,
TimeStamp = latest.EntryDate.ConvertLocalToUTC(),
Archived = false,
PickedReason = PickedReason.Production
};
pickedInventory.Items = CreatePickedInventoryItems(pickedInventory, batch.BatchItems).ToList();
return(pickedInventory);
}
internal static List <ModifyPickedInventoryItemParameters> CreateModifyPickedInventoryItemParameters(PickedInventory pickedInventory, List <PickedInventoryParameters> newItems)
{
if (pickedInventory.Items == null)
{
throw new ArgumentNullException("pickedInventory.Items");
}
var removeModifications = pickedInventory.Items.Select(i => new ModifyPickedInventoryItemParameters(i)).ToList();
var modifications = new List <ModifyPickedInventoryItemParameters>();
foreach (var newItem in newItems ?? new List <PickedInventoryParameters>())
{
var closestMatch = ClosestMatch(removeModifications, newItem);
if (closestMatch != null)
{
if (closestMatch.OriginalQuantity != newItem.Quantity ||
closestMatch.CustomerLotCode != newItem.CustomerLotCode || closestMatch.CustomerProductCode != newItem.CustomerProductCode ||
!closestMatch.CurrentLocationKey.Equals(newItem.CurrentLocationKey))
{
closestMatch.NewQuantity = newItem.Quantity;
closestMatch.CurrentLocationKey = newItem.CurrentLocationKey;
closestMatch.CustomerLotCode = newItem.CustomerLotCode;
closestMatch.CustomerProductCode = newItem.CustomerProductCode;
modifications.Add(closestMatch);
}
removeModifications.Remove(closestMatch);
}
else
{
modifications.Add(new ModifyPickedInventoryItemParameters(newItem.InventoryKey, newItem.CurrentLocationKey, newItem.Quantity, newItem.CustomerLotCode, newItem.CustomerProductCode, newItem.OrderItemKey));
}
}
modifications.AddRange(removeModifications);
return(modifications);
}
protected IResult UpdatePickedInventory(IInventoryValidator inventoryValidator, Employee employee, DateTime timeStamp, PickedInventory existingPickedInventory, List <PickedInventoryParameters> setPickedInventoryItems, ref List <ModifyInventoryParameters> pendingInventoryModifications, bool moveToDestination = false)
{
if (employee != null)
{
existingPickedInventory.EmployeeId = employee.EmployeeId;
}
existingPickedInventory.TimeStamp = timeStamp;
var pickedInventoryModifications = PickedInventoryHelper.CreateModifyPickedInventoryItemParameters(existingPickedInventory, setPickedInventoryItems);
if (inventoryValidator != null)
{
var validatorResult = inventoryValidator.ValidateItems(UnitOfWork.InventoryRepository, pickedInventoryModifications.Where(i => i.DeltaQuantity > 0).Select(i => i.InventoryKey));
if (!validatorResult.Success)
{
return(validatorResult.ConvertTo <List <PickedInventoryItem> >());
}
}
var modifyPickedResult = new ModifyPickedInventoryItemsCommand(UnitOfWork).Execute(existingPickedInventory, pickedInventoryModifications);
if (!modifyPickedResult.Success)
{
return(modifyPickedResult);
}
pendingInventoryModifications = pendingInventoryModifications ?? new List <ModifyInventoryParameters>();
pendingInventoryModifications.AddRange(pickedInventoryModifications.Select(p => p.ToModifySourceInventoryParameters()));
if (moveToDestination)
{
pendingInventoryModifications.AddRange(pickedInventoryModifications.Select(p => p.ToModifyDestinationInventoryParameters()));
}
return(modifyPickedResult);
}
protected IResult UpdatePickedInventory(IInventoryValidator inventoryValidator, Employee employee, DateTime timeStamp, PickedInventory existingPickedInventory, List <PickedInventoryParameters> setPickedInventoryItems, bool moveToDestination = false)
{
List <ModifyInventoryParameters> inventoryModifications = null;
var updateResult = UpdatePickedInventory(inventoryValidator, employee, timeStamp, existingPickedInventory, setPickedInventoryItems, ref inventoryModifications, moveToDestination);
if (!updateResult.Success)
{
return(updateResult.ConvertTo <List <PickedInventoryItem> >());
}
var modifyInventoryResult = new ModifyInventoryCommand(UnitOfWork).Execute(inventoryModifications, null);
if (!modifyInventoryResult.Success)
{
return(modifyInventoryResult.ConvertTo <List <PickedInventoryItem> >());
}
return(updateResult);
}
private IEnumerable <PickedInventoryItem> CreatePickedInventoryItems(PickedInventory pickedInventory, IEnumerable <tblBatchItemDTO> batchItems)
{
var itemSequence = 1;
foreach (var batchItem in batchItems)
{
_loadCount.AddRead(EntityTypes.PickedInventoryItem);
LotKey lotKey;
if (!LotNumberParser.ParseLotNumber(batchItem.Lot, out lotKey))
{
Log(new CallbackParameters(CallbackReason.BatchItemInvalidLotNumber)
{
BatchItem = batchItem
});
continue;
}
if (!_newContextHelper.LotLoaded(lotKey))
{
Log(new CallbackParameters(CallbackReason.BatchItemLotNotLoaded)
{
BatchItem = batchItem
});
continue;
}
var packaging = batchItem.PTypeID == (int?)LotTypeEnum.Packaging ? _newContextHelper.NoPackagingProduct : _newContextHelper.GetPackagingProduct(batchItem.PkgID);
if (packaging == null)
{
Log(new CallbackParameters(CallbackReason.BatchItemPackagingNotLoaded)
{
BatchItem = batchItem
});
continue;
}
var treatment = _newContextHelper.GetInventoryTreatment(batchItem.TrtmtID);
if (treatment == null)
{
Log(new CallbackParameters(CallbackReason.BatchItemTreatmentNotLoaded)
{
BatchItem = batchItem
});
continue;
}
int?currentLocationId = null;
var productionLocation = _newContextHelper.GetProductionLocation(batchItem.tblLocation);
if (productionLocation != null)
{
currentLocationId = productionLocation.Id;
}
else
{
var warehouseLocation = _newContextHelper.GetLocation(batchItem.LocID);
if (warehouseLocation != null)
{
currentLocationId = warehouseLocation.Id;
}
}
if (currentLocationId == null)
{
Log(new CallbackParameters(CallbackReason.BatchItemCurrentLocationCouldnotBeDetermined)
{
BatchItem = batchItem
});
continue;
}
int?warehouseLocationId;
var warehouseLocationResult = _pickedInventoryItemLocationHelper.DeterminePickedFromLocation(batchItem, out warehouseLocationId);
if (warehouseLocationResult == PickedInventoryItemLocationHelper.Result.UnableToDetermine)
{
Log(new CallbackParameters(CallbackReason.BatchItemDefaultPickedLocation)
{
BatchItem = batchItem
});
warehouseLocationId = _newContextHelper.UnknownFacilityLocation.Id;
}
if (warehouseLocationId == null)
{
Log(new CallbackParameters(CallbackReason.BatchItemPickedLocationNotDetermined)
{
BatchItem = batchItem
});
continue;
}
yield return(new PickedInventoryItem
{
DateCreated = pickedInventory.DateCreated,
Sequence = pickedInventory.Sequence,
ItemSequence = itemSequence,
LotDateCreated = lotKey.LotKey_DateCreated,
LotDateSequence = lotKey.LotKey_DateSequence,
LotTypeId = lotKey.LotKey_LotTypeId,
PackagingProductId = packaging.Id,
FromLocationId = warehouseLocationId.Value,
TreatmentId = treatment.Id,
CurrentLocationId = currentLocationId.Value,
ToteKey = new string((batchItem.Tote ?? "").Take(Constants.StringLengths.ToteKeyLength).ToArray()),
Quantity = (int)(batchItem.Quantity ?? 0)
});
itemSequence += 1;
}
}
