public IResult <ILotHistoryReturn> GetLotHistory(string lotKey)
{
var lotKeyResult = KeyParserHelper.ParseResult <ILotKey>(lotKey);
if (!lotKeyResult.Success)
{
return(lotKeyResult.ConvertTo <ILotHistoryReturn>());
}
var parsedLotKey = lotKeyResult.ResultingObject.ToLotKey();
var result = _lotUnitOfWork.LotRepository
.FilterByKey(parsedLotKey)
.SplitSelect(LotProjectors.SplitSelectHistory())
.FirstOrDefault();
if (result == null)
{
return(new InvalidResult <ILotHistoryReturn>(null, string.Format(UserMessages.LotNotFound, parsedLotKey)));
}
return(new SuccessResult <ILotHistoryReturn>(result));
}
internal static IResult <ProductionSchedulePredicateBuilder.PredicateBuilderFilters> ToParsedParameters(this FilterProductionScheduleParameters parameters)
{
var filterParameters = new ProductionSchedulePredicateBuilder.PredicateBuilderFilters();
if (parameters != null)
{
filterParameters.ProductionDate = parameters.ProductionDate;
if (!string.IsNullOrWhiteSpace(parameters.ProductionLineLocationKey))
{
var locationKeyResult = KeyParserHelper.ParseResult <ILocationKey>(parameters.ProductionLineLocationKey);
if (!locationKeyResult.Success)
{
return(locationKeyResult.ConvertTo <ProductionSchedulePredicateBuilder.PredicateBuilderFilters>());
}
filterParameters.ProductionLineLocationKey = locationKeyResult.ResultingObject.ToLocationKey();
}
}
return(new SuccessResult <ProductionSchedulePredicateBuilder.PredicateBuilderFilters>(filterParameters));
}
public IResult <ISalesQuoteDetailReturn> GetSalesQuote(string salesQuoteKey)
{
var parsedKeyResult = KeyParserHelper.ParseResult <ISalesQuoteKey>(salesQuoteKey);
if (!parsedKeyResult.Success)
{
return(parsedKeyResult.ConvertTo <ISalesQuoteDetailReturn>());
}
var key = parsedKeyResult.ResultingObject.ToSalesQuoteKey();
var result = _inventoryShipmentOrderUnitOfWork.SalesQuoteRepository
.Filter(key.FindByPredicate)
.Select(SalesQuoteProjectors.SelectDetail())
.FirstOrDefault();
if (result == null)
{
return(new InvalidResult <ISalesQuoteDetailReturn>(null, string.Format(UserMessages.SalesQuoteNotFound_Key, key)));
}
return(new SuccessResult <ISalesQuoteDetailReturn>(result));
}
public SetInventoryShipmentOrderConductorParameters(TParams parameters)
{
Params = parameters;
if (parameters.DestinationFacilityKey != null)
{
var facilityKeyResult = KeyParserHelper.ParseResult <IFacilityKey>(parameters.DestinationFacilityKey);
if (!facilityKeyResult.Success)
{
_result = facilityKeyResult;
return;
}
DestinationFacilityKey = new FacilityKey(facilityKeyResult.ResultingObject);
}
if (parameters.SourceFacilityKey != null)
{
var sourceKeyResult = KeyParserHelper.ParseResult <IFacilityKey>(parameters.SourceFacilityKey);
if (!sourceKeyResult.Success)
{
_result = sourceKeyResult;
return;
}
SourceFacilityKey = new FacilityKey(sourceKeyResult.ResultingObject);
}
if (parameters.InventoryPickOrderItems != null)
{
var pickOrderItemsResult = parameters.InventoryPickOrderItems.ToParsedItems();
if (!pickOrderItemsResult.Success)
{
_result = pickOrderItemsResult;
return;
}
PickOrderItems = pickOrderItemsResult.ResultingObject.Cast <ISchedulePickOrderItemParameter>().ToList();
}
}
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 <ISampleOrderDetailReturn> GetSampleOrder(string sampleOrderKey)
{
var keyResult = KeyParserHelper.ParseResult <ISampleOrderKey>(sampleOrderKey);
if (!keyResult.Success)
{
return(keyResult.ConvertTo <ISampleOrderDetailReturn>());
}
var key = keyResult.ResultingObject.ToSampleOrderKey();
var predicate = SampleOrderPredicates.ByKey(key);
var select = SampleOrderProjectors.SelectDetail();
var result = _sampleOrderUnitOfWork.SampleOrderRepository.Filter(predicate).SplitSelect(select).FirstOrDefault();
if (result == null)
{
return(new InvalidResult <ISampleOrderDetailReturn>(null, string.Format(UserMessages.SampleOrderNotFound, key)));
}
return(new SuccessResult <ISampleOrderDetailReturn>(result));
}
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);
}
internal static IResult <AddLotAttributeParameters> ToParsedParameters(this IAddLotAttributesParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var lotKeys = new List <LotKey>();
foreach (var lotKey in parameters.LotKeys)
{
var lotKeyResult = KeyParserHelper.ParseResult <ILotKey>(lotKey);
if (!lotKeyResult.Success)
{
return(lotKeyResult.ConvertTo <AddLotAttributeParameters>());
}
lotKeys.Add(lotKeyResult.ResultingObject.ToLotKey());
}
var attributes = new Dictionary <AttributeNameKey, IAttributeValueParameters>();
foreach (var attribute in parameters.Attributes)
{
var attributeNameResult = KeyParserHelper.ParseResult <IAttributeNameKey>(attribute.Key);
if (!attributeNameResult.Success)
{
return(attributeNameResult.ConvertTo <AddLotAttributeParameters>());
}
attributes.Add(new AttributeNameKey(attributeNameResult.ResultingObject), attribute.Value);
}
return(new SuccessResult <AddLotAttributeParameters>(new AddLotAttributeParameters
{
Parameters = parameters,
LotKeys = lotKeys,
Attributes = attributes
}));
}
public IResult <IContractShipmentSummaryReturn> GetContractShipmentSummary(string contractKey)
{
var contractKeyResult = KeyParserHelper.ParseResult <IContractKey>(contractKey);
if (!contractKeyResult.Success)
{
return(contractKeyResult.ConvertTo <IContractShipmentSummaryReturn>());
}
var key = new ContractKey(contractKeyResult.ResultingObject);
var select = ContractProjectors.SplitSelectShipmentSummary();
var contract = _inventoryShipmentOrderUnitOfWork.ContractRepository
.All().Where(key.FindByPredicate)
.SplitSelect(select).FirstOrDefault();
if (contract == null)
{
return(new InvalidResult <IContractShipmentSummaryReturn>(null, string.Format(UserMessages.CustomerContractNotFound, contractKey)));
}
return(new SuccessResult <IContractShipmentSummaryReturn>(contract));
}
internal static IResult <SalesOrderPredicateBuilder.PredicateBuilderFilters> ParseToPredicateBuilderFilters(this FilterSalesOrdersParameters parameters)
{
if (parameters == null)
{
return(new SuccessResult <SalesOrderPredicateBuilder.PredicateBuilderFilters>());
}
var result = new SalesOrderPredicateBuilder.PredicateBuilderFilters
{
SalesOrderStatus = parameters.SalesOrderStatus,
OrderReceivedRangeStart = parameters.OrderReceivedRangeStart,
OrderReceivedRangeEnd = parameters.OrderReceivedRangeEnd,
ScheduledShipDateRangeStart = parameters.ScheduledShipDateRangeStart,
ScheduledShipDateRangeEnd = parameters.ScheduledShipDateRangeEnd,
};
if (parameters.CustomerKey != null)
{
var customerKeyResult = KeyParserHelper.ParseResult <ICustomerKey>(parameters.CustomerKey);
if (!customerKeyResult.Success)
{
return(customerKeyResult.ConvertTo <SalesOrderPredicateBuilder.PredicateBuilderFilters>());
}
result.CustomerKey = customerKeyResult.ResultingObject;
}
if (parameters.BrokerKey != null)
{
var brokerKeyResult = KeyParserHelper.ParseResult <ICompanyKey>(parameters.BrokerKey);
if (!brokerKeyResult.Success)
{
return(brokerKeyResult.ConvertTo <SalesOrderPredicateBuilder.PredicateBuilderFilters>());
}
result.BrokerKey = brokerKeyResult.ResultingObject;
}
return(new SuccessResult <SalesOrderPredicateBuilder.PredicateBuilderFilters>(result));
}
internal static IResult <LotAllowanceParameters> ToParsedParameters(this ILotAllowanceParameters parameters)
{
var lotKey = KeyParserHelper.ParseResult <ILotKey>(parameters.LotKey);
if (!lotKey.Success)
{
return(lotKey.ConvertTo <LotAllowanceParameters>());
}
var customerKey = string.IsNullOrWhiteSpace(parameters.CustomerKey) ? null : KeyParserHelper.ParseResult <ICustomerKey>(parameters.CustomerKey);
if (customerKey != null && !customerKey.Success)
{
return(customerKey.ConvertTo <LotAllowanceParameters>());
}
var contractKey = string.IsNullOrWhiteSpace(parameters.ContractKey) ? null : KeyParserHelper.ParseResult <IContractKey>(parameters.ContractKey);
if (contractKey != null && !contractKey.Success)
{
return(contractKey.ConvertTo <LotAllowanceParameters>());
}
var customerOrderKey = string.IsNullOrWhiteSpace(parameters.CustomerOrderKey) ? null : KeyParserHelper.ParseResult <ISalesOrderKey>(parameters.CustomerOrderKey);
if (customerOrderKey != null && !customerOrderKey.Success)
{
return(customerOrderKey.ConvertTo <LotAllowanceParameters>());
}
return(new SuccessResult <LotAllowanceParameters>(new LotAllowanceParameters
{
LotKey = lotKey.ResultingObject.ToLotKey(),
CustomerKey = customerKey == null ? null : customerKey.ResultingObject.ToCustomerKey(),
ContractKey = contractKey == null ? null : contractKey.ResultingObject.ToContractKey(),
SalesOrderKey = customerOrderKey == null ? null : customerOrderKey.ResultingObject.ToSalesOrderKey()
}));
}
public IResult DeleteFacility(string facilityKey)
{
var key = KeyParserHelper.ParseResult <IFacilityKey>(facilityKey);
if (!key.Success)
{
return(key);
}
var facilityResult = new DeleteFacilityCommand(_facilityUnitOfWork).DeleteFacility(key.ResultingObject);
if (!facilityResult.Success)
{
return(facilityResult);
}
_facilityUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new SyncFacilityParameters
{
DeleteWHID = facilityResult.ResultingObject.WHID
}));
}
public IResult UpdateFacility(IUpdateFacilityParameters parameters)
{
var key = KeyParserHelper.ParseResult <IFacilityKey>(parameters.FacilityKey);
if (!key.Success)
{
return(key);
}
var facilityResult = new UpdateFacilityCommand(_facilityUnitOfWork).UpdateFacility(key.ResultingObject, parameters);
if (!facilityResult.Success)
{
return(facilityResult.ConvertTo <string>());
}
_facilityUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new SyncFacilityParameters
{
FacilityKey = key.ResultingObject
}));
}
internal static IResult <CompanyPredicateBuilder.PredicateBuilderFilters> ToParsedParameters(this FilterCompanyParameters parameters)
{
var result = new CompanyPredicateBuilder.PredicateBuilderFilters();
if (parameters != null)
{
result.CompanyType = parameters.CompanyType;
result.IncludeInactive = parameters.IncludeInactive ?? false;
if (parameters.BrokerKey != null)
{
var brokerKeyResult = KeyParserHelper.ParseResult <ICompanyKey>(parameters.BrokerKey);
if (!brokerKeyResult.Success)
{
return(brokerKeyResult.ConvertTo <CompanyPredicateBuilder.PredicateBuilderFilters>());
}
result.BrokerKey = brokerKeyResult.ResultingObject.ToCompanyKey();
}
}
return(new SuccessResult <CompanyPredicateBuilder.PredicateBuilderFilters>(result));
}
public IResult <IInventoryCycleCountReportReturn> GetInventoryCycleCountReport(string facilityKey, string groupName)
{
var facilityKeyResult = KeyParserHelper.ParseResult <IFacilityKey>(facilityKey);
if (!facilityKeyResult.Success)
{
return(facilityKeyResult.ConvertTo <IInventoryCycleCountReportReturn>());
}
var parsedFacilityKey = facilityKeyResult.ResultingObject.ToFacilityKey();
var predicate = parsedFacilityKey.FindByPredicate;
var select = FacilityProjectors.SelectInventoryCycleCount(groupName);
var facility = _inventoryUnitOfWork.FacilityRepository.Filter(predicate).Select(select).FirstOrDefault();
if (facility == null)
{
return(new InvalidResult <IInventoryCycleCountReportReturn>(null, string.Format(UserMessages.FacilityNotFound, facilityKey)));
}
facility.Initialize();
return(new SuccessResult <IInventoryCycleCountReportReturn>(facility));
}
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));
}
internal static IResult <InventoryPredicateBuilder.PredicateBuilderFilters> ParseToPredicateBuilderFilters(this FilterInventoryParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var baseResult = (parameters as FilterInventoryParametersBase).ParseToPredicateBuilderFilters();
if (!baseResult.Success)
{
return(baseResult);
}
var filters = baseResult.ResultingObject;
if (!string.IsNullOrEmpty(parameters.FacilityKey))
{
var warehouseKeyResult = KeyParserHelper.ParseResult <IFacilityKey>(parameters.FacilityKey);
if (!warehouseKeyResult.Success)
{
return(warehouseKeyResult.ConvertTo <InventoryPredicateBuilder.PredicateBuilderFilters>());
}
filters.FacilityKey = warehouseKeyResult.ResultingObject;
}
if (!string.IsNullOrEmpty(parameters.ToteKey))
{
filters.ToteKey = parameters.ToteKey.ToToteKey();
}
if (!string.IsNullOrWhiteSpace(parameters.LocationGroupName))
{
filters.LocationGroupName = parameters.LocationGroupName;
}
return(new SuccessResult <InventoryPredicateBuilder.PredicateBuilderFilters>(filters));
}
public IResult SetPickedInventory(string contextKey, ISetPickedInventoryParameters parameters)
{
var orderKeyResult = KeyParserHelper.ParseResult <IInventoryShipmentOrderKey>(contextKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult);
}
var orderKey = orderKeyResult.ResultingObject.ToInventoryShipmentOrderKey();
var parsedParameters = parameters.PickedInventoryItems.ToParsedParameters();
if (!parsedParameters.Success)
{
return(parsedParameters);
}
var setResult = new TreatmentOrderPickedInventoryConductor(_inventoryShipmentOrderUnitOfWork).SetPickedInventory(_timeStamper.CurrentTimeStamp, new InventoryShipmentOrderPickInventoryConductor.Parameters
{
User = parameters,
OrderKey = orderKey,
PickedInventoryParameters = parsedParameters.ResultingObject
});
if (!setResult.Success)
{
return(setResult);
}
_inventoryShipmentOrderUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new SyncInventoryShipmentOrderParameters
{
InventoryShipmentOrderKey = orderKey,
New = false
}));
}
public IResult RemoveCustomerChileProductAttributeRanges(IRemoveCustomerChileProductAttributeRangesParameters parameters)
{
var customerKey = KeyParserHelper.ParseResult <ICustomerKey>(parameters.CustomerKey);
if (!customerKey.Success)
{
return(customerKey);
}
var chileProductKey = KeyParserHelper.ParseResult <IChileProductKey>(parameters.ChileProductKey);
if (!chileProductKey.Success)
{
return(chileProductKey);
}
int? prodId;
string companyIA;
var result = new RemoveCustomerChileProductAttributeRangesCommand(_inventoryShipmentOrderUnitOfWork).Execute(customerKey.ResultingObject, chileProductKey.ResultingObject, out prodId, out companyIA);
if (!result.Success)
{
return(result);
}
_inventoryShipmentOrderUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new SynchronizeCustomerProductSpecs
{
Delete = prodId == null || string.IsNullOrWhiteSpace(companyIA) ? null :
new SerializedSpecKey
{
ProdID = prodId.Value,
Company_IA = companyIA
}
}));
}
public IResult SetCustomerContractsStatus(ISetContractsStatusParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var contractKeys = new List <ContractKey>();
foreach (var key in parameters.ContractKeys.Distinct().Where(k => !string.IsNullOrWhiteSpace(k)))
{
var keyResult = KeyParserHelper.ParseResult <IContractKey>(key);
if (!keyResult.Success)
{
return(keyResult);
}
contractKeys.Add(new ContractKey(keyResult.ResultingObject));
}
if (contractKeys.Any())
{
var predicate = contractKeys.Aggregate(PredicateBuilder.False <Contract>(), (c, n) => c.Or(n.FindByPredicate)).ExpandAll();
var contracts = _inventoryShipmentOrderUnitOfWork.ContractRepository.Filter(predicate).ToList();
var missingKey = contractKeys.FirstOrDefault(k => contracts.All(c => !k.FindByPredicate.Invoke(c)));
if (missingKey != null)
{
return(new InvalidResult(string.Format(UserMessages.CustomerContractNotFound, missingKey)));
}
contracts.ForEach(c => c.ContractStatus = parameters.ContractStatus);
_inventoryShipmentOrderUnitOfWork.Commit();
}
return(SyncParameters.Using(new SuccessResult(), contractKeys));
}
internal static IResult <ContractPredicateBuilder.PredicateBuilderFilters> ParseToPredicateBuilderFilters(this FilterCustomerContractsParameters parameters)
{
if (parameters == null)
{
return(new SuccessResult <ContractPredicateBuilder.PredicateBuilderFilters>());
}
var result = new ContractPredicateBuilder.PredicateBuilderFilters
{
ContractStatus = parameters.ContractStatus,
TermBeginRangeStart = parameters.TermBeginRangeStart,
TermBeginRangeEnd = parameters.TermBeginRangeEnd
};
if (parameters.CustomerKey != null)
{
var customerKeyResult = KeyParserHelper.ParseResult <ICustomerKey>(parameters.CustomerKey);
if (!customerKeyResult.Success)
{
return(customerKeyResult.ConvertTo <ContractPredicateBuilder.PredicateBuilderFilters>());
}
result.CustomerKey = customerKeyResult.ResultingObject;
}
if (parameters.BrokerKey != null)
{
var brokerKeyResult = KeyParserHelper.ParseResult <ICompanyKey>(parameters.BrokerKey);
if (!brokerKeyResult.Success)
{
return(brokerKeyResult.ConvertTo <ContractPredicateBuilder.PredicateBuilderFilters>());
}
result.BrokerKey = brokerKeyResult.ResultingObject;
}
return(new SuccessResult <ContractPredicateBuilder.PredicateBuilderFilters>(result));
}
internal static IResult <UpdateAdditiveProductParameters> ToParsedParameters(this IUpdateAdditiveProductParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var baseResult = ToParsedParameters <UpdateAdditiveProductParameters, IUpdateAdditiveProductParameters>(parameters);
if (!baseResult.Success)
{
return(baseResult);
}
var additiveTypeKeyResult = KeyParserHelper.ParseResult <IAdditiveTypeKey>(parameters.AdditiveTypeKey);
if (!additiveTypeKeyResult.Success)
{
return(additiveTypeKeyResult.ConvertTo <UpdateAdditiveProductParameters>());
}
baseResult.ResultingObject.AdditiveTypeKey = additiveTypeKeyResult.ResultingObject.ToAdditiveTypeKey();
return(baseResult);
}
public void Creates_new_Facility_as_expected()
{
//Arrange
var parameters = new UpdateFacilityParameters
{
UserToken = TestUser.UserName,
FacilityType = FacilityType.Internal,
Name = "Bob's House of Magical Wonders",
ShippingLabelName = "Bob Incorporated",
Active = false,
PhoneNumber = "123-456-7890",
EMailAddress = "*****@*****.**",
Address = new Address(),
};
//Act
var result = Service.CreateFacility(parameters);
//Assert
result.AssertSuccess();
var key = KeyParserHelper.ParseResult <IFacilityKey>(result.ResultingObject).ResultingObject.ToFacilityKey();
RVCUnitOfWork.FacilityRepository.FindByKey(key).AssertEqual(parameters);
}
internal static IResult <CreateChileProductParameters> ToParsedParameters(this ICreateChileProductParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var chileTypeKeyResult = KeyParserHelper.ParseResult <IChileTypeKey>(parameters.ChileTypeKey);
if (!chileTypeKeyResult.Success)
{
return(chileTypeKeyResult.ConvertTo <CreateChileProductParameters>());
}
var rangesResult = parameters.AttributeRanges.ToParsedParameters(r => r.ToParsedParameters());
if (!rangesResult.Success)
{
return(rangesResult.ConvertTo <CreateChileProductParameters>());
}
var ingredientsResult = parameters.Ingredients.ToParsedParameters(i => i.ToParsedParameters());
if (!ingredientsResult.Success)
{
return(ingredientsResult.ConvertTo <CreateChileProductParameters>());
}
return(new SuccessResult().ConvertTo(new CreateChileProductParameters
{
Parameters = parameters,
ChileTypeKey = chileTypeKeyResult.ResultingObject.ToChileTypeKey(),
AttributeRanges = rangesResult.ResultingObject,
Ingredients = ingredientsResult.ResultingObject
}));
}
internal static IResult <SetCustomerProductAttributeRangesParameters> ToParsedParameters(this ISetCustomerProductAttributeRangesParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var customerKeyResult = KeyParserHelper.ParseResult <ICustomerKey>(parameters.CustomerKey);
if (!customerKeyResult.Success)
{
return(customerKeyResult.ConvertTo <SetCustomerProductAttributeRangesParameters>());
}
var chileProductKeyResult = KeyParserHelper.ParseResult <IChileProductKey>(parameters.ChileProductKey);
if (!chileProductKeyResult.Success)
{
return(chileProductKeyResult.ConvertTo <SetCustomerProductAttributeRangesParameters>());
}
var attributeRanges = parameters.AttributeRanges.ToParsedParameters(i => i.ToParsedParameters());
if (!attributeRanges.Success)
{
return(attributeRanges.ConvertTo <SetCustomerProductAttributeRangesParameters>());
}
return(new SuccessResult().ConvertTo(new SetCustomerProductAttributeRangesParameters
{
Parameters = parameters,
CustomerKey = customerKeyResult.ResultingObject.ToCustomerKey(),
ChileProductKey = chileProductKeyResult.ResultingObject.ToChileProductKey(),
AttributeRanges = attributeRanges.ResultingObject
}));
}
public IResult AssignCustomerToBroker(string brokerKey, string customerKey)
{
if (brokerKey == null)
{
throw new ArgumentNullException("brokerKey");
}
if (customerKey == null)
{
throw new ArgumentNullException("customerKey");
}
var brokerKeyResult = KeyParserHelper.ParseResult <ICompanyKey>(brokerKey);
if (!brokerKeyResult.Success)
{
return(brokerKeyResult);
}
var customerKeyResult = KeyParserHelper.ParseResult <ICustomerKey>(customerKey);
if (!customerKeyResult.Success)
{
return(customerKeyResult);
}
var commandResult = new AssignCustomerToBrokerCommand(_inventoryShipmentOrderUnitOfWork).Execute(new CompanyKey(brokerKeyResult.ResultingObject), new CustomerKey(customerKeyResult.ResultingObject));
if (!commandResult.Success)
{
return(commandResult);
}
_inventoryShipmentOrderUnitOfWork.Commit();
return(new SuccessResult());
}
internal static IResult <ProductionResultParameters> ToParsedParameters(this IUpdateProductionBatchResultsParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parametersResult = ToBaseParameters(parameters);
if (!parametersResult.Success)
{
return(parametersResult);
}
var lotKeyResult = KeyParserHelper.ParseResult <ILotKey>(parameters.ProductionResultKey);
if (!lotKeyResult.Success)
{
return(lotKeyResult.ConvertTo <ProductionResultParameters>());
}
parametersResult.ResultingObject.LotKey = new LotKey(lotKeyResult.ResultingObject);
return(parametersResult);
}
internal static IResult <ReceiveInventoryItemParameters> ToParsedParameters(this IReceiveInventoryItemParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var packagingKeyResult = KeyParserHelper.ParseResult <IPackagingProductKey>(parameters.PackagingProductKey);
if (!packagingKeyResult.Success)
{
return(packagingKeyResult.ConvertTo <ReceiveInventoryItemParameters>());
}
var warehouseLocationKeyResult = KeyParserHelper.ParseResult <ILocationKey>(parameters.WarehouseLocationKey);
if (!warehouseLocationKeyResult.Success)
{
return(warehouseLocationKeyResult.ConvertTo <ReceiveInventoryItemParameters>());
}
var inventoryTreatmentKeyResult = KeyParserHelper.ParseResult <IInventoryTreatmentKey>(parameters.TreatmentKey);
if (!inventoryTreatmentKeyResult.Success)
{
return(inventoryTreatmentKeyResult.ConvertTo <ReceiveInventoryItemParameters>());
}
return(new SuccessResult <ReceiveInventoryItemParameters>(new ReceiveInventoryItemParameters
{
Parameters = parameters,
PackagingProductKey = new PackagingProductKey(packagingKeyResult.ResultingObject),
LocationKey = new LocationKey(warehouseLocationKeyResult.ResultingObject),
TreatmentKey = new InventoryTreatmentKey(inventoryTreatmentKeyResult.ResultingObject)
}));
}
internal static IResult <UpdateContactCommandParameters> ToParsedParameters(this IUpdateContactParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var contactKeyResult = KeyParserHelper.ParseResult <IContactKey>(parameters.ContactKey);
if (!contactKeyResult.Success)
{
return(contactKeyResult.ConvertTo <UpdateContactCommandParameters>());
}
var updateAddresses = new List <SetContactAddressParameters>();
if (parameters.Addresses != null)
{
foreach (var address in parameters.Addresses)
{
var addressResult = address.ToParsedParameters();
if (!addressResult.Success)
{
return(addressResult.ConvertTo <UpdateContactCommandParameters>());
}
updateAddresses.Add(addressResult.ResultingObject);
}
}
return(new SuccessResult <UpdateContactCommandParameters>(new UpdateContactCommandParameters
{
Parameters = parameters,
ContactKey = contactKeyResult.ResultingObject.ToContactKey(),
SetAddresses = updateAddresses
}));
}
internal static IResult <UpdateCustomerContractCommandParameters> ToParsedParameters(this IUpdateCustomerContractParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
if (parameters.ContractItems == null || !parameters.ContractItems.Any())
{
return(new InvalidResult <UpdateCustomerContractCommandParameters>(null, UserMessages.ContractItemsRequired));
}
if (parameters.TermBegin >= parameters.TermEnd)
{
return(new InvalidResult <UpdateCustomerContractCommandParameters>(null, string.Format(UserMessages.ContractTermMustBeginBeforeEnd, parameters.TermBegin, parameters.TermEnd)));
}
var contractKeyResult = KeyParserHelper.ParseResult <IContractKey>(parameters.ContractKey);
if (!contractKeyResult.Success)
{
return(contractKeyResult.ConvertTo((UpdateCustomerContractCommandParameters)null));
}
var customerKeyResult = KeyParserHelper.ParseResult <ICustomerKey>(parameters.CustomerKey);
if (!customerKeyResult.Success)
{
return(customerKeyResult.ConvertTo((UpdateCustomerContractCommandParameters)null));
}
var brokerKeyResult = KeyParserHelper.ParseResult <ICompanyKey>(parameters.BrokerKey);
if (!brokerKeyResult.Success)
{
return(brokerKeyResult.ConvertTo((UpdateCustomerContractCommandParameters)null));
}
FacilityKey facilityKey = null;
if (!string.IsNullOrWhiteSpace(parameters.DefaultPickFromWarehouseKey))
{
var warehouseKeyResult = KeyParserHelper.ParseResult <IFacilityKey>(parameters.DefaultPickFromWarehouseKey);
if (!warehouseKeyResult.Success)
{
return(warehouseKeyResult.ConvertTo((UpdateCustomerContractCommandParameters)null));
}
facilityKey = new FacilityKey(warehouseKeyResult.ResultingObject);
}
var contractItems = new List <SetContractItemParameters>();
foreach (var item in parameters.ContractItems)
{
var parseItemResult = item.ToParsedParameters();
if (!parseItemResult.Success)
{
return(parseItemResult.ConvertTo((UpdateCustomerContractCommandParameters)null));
}
contractItems.Add(parseItemResult.ResultingObject);
}
return(new SuccessResult <UpdateCustomerContractCommandParameters>(new UpdateCustomerContractCommandParameters
{
UpdateCustomerContractParameters = parameters,
ContractKey = new ContractKey(contractKeyResult.ResultingObject),
CustomerKey = new CustomerKey(customerKeyResult.ResultingObject),
BrokerKey = new CompanyKey(brokerKeyResult.ResultingObject),
DefaultPickFromFacilityKey = facilityKey,
ContractItems = contractItems
}));
}
