public IResult <string> UpdatePackSchedule(IUpdatePackScheduleParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parametersResult = parameters.ToParsedParameters();
if (!parametersResult.Success)
{
return(parametersResult.ConvertTo <string>());
}
var result = new UpdatePackScheduleCommand(_productionUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, parametersResult.ResultingObject);
if (!result.Success)
{
return(result.ConvertTo <string>());
}
_productionUnitOfWork.Commit();
var packScheduleKey = result.ResultingObject.ToPackScheduleKey();
return(SyncParameters.Using(new SuccessResult <string>(packScheduleKey), packScheduleKey));
}
public IResult <string> CreateInventoryAdjustment(ICreateInventoryAdjustmentParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parseResult = parameters.ToParsedParameters();
if (!parseResult.Success)
{
return(parseResult.ConvertTo <string>());
}
var createResult = new CreateInventoryAdjustmentConductor(_inventoryUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, parseResult.ResultingObject);
if (!createResult.Success)
{
return(createResult.ConvertTo <string>());
}
_inventoryUnitOfWork.Commit();
var key = new InventoryAdjustmentKey(createResult.ResultingObject);
return(SyncParameters.Using(new SuccessResult <string>(key), key));
}
public IResult PickInventoryForProductionBatch(string productionBatchKey, ISetPickedInventoryParameters pickedInventory)
{
if (productionBatchKey == null)
{
throw new ArgumentNullException("productionBatchKey");
}
if (pickedInventory == null)
{
throw new ArgumentNullException("pickedInventory");
}
var productionBatchKeyResult = KeyParserHelper.ParseResult <ILotKey>(productionBatchKey);
if (!productionBatchKeyResult.Success)
{
return(productionBatchKeyResult);
}
var lotKey = productionBatchKeyResult.ResultingObject.ToLotKey();
var result = new ProductionBatchPickInventoryConductor(_productionUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, pickedInventory, lotKey);
if (!result.Success)
{
return(result);
}
_productionUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), lotKey));
}
public IResult DeleteProductionSchedule(string productionScheduleKey)
{
var keyResult = KeyParserHelper.ParseResult <IProductionScheduleKey>(productionScheduleKey);
if (!keyResult.Success)
{
return(keyResult);
}
var scheduleKey = keyResult.ResultingObject.ToProductionScheduleKey();
var productionSchedule = _productionUnitOfWork.ProductionScheduleRepository.FindByKey(scheduleKey,
p => p.ProductionLineLocation,
p => p.ScheduledItems);
if (productionSchedule == null)
{
return(new NoWorkRequiredResult());
}
foreach (var item in productionSchedule.ScheduledItems.ToList())
{
_productionUnitOfWork.ProductionScheduleItemRepository.Remove(item);
}
_productionUnitOfWork.ProductionScheduleRepository.Remove(productionSchedule);
_productionUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), scheduleKey));
}
public IResult <ICreateProductionBatchReturn> CreateProductionBatch(ICreateProductionBatchParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parametersResult = parameters.ToParsedParameters();
if (!parametersResult.Success)
{
return(parametersResult.ConvertTo <ICreateProductionBatchReturn>());
}
var result = new CreateProductionBatchCommand(_productionUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, parametersResult.ResultingObject);
if (!result.Success)
{
return(result.ConvertTo <ICreateProductionBatchReturn>());
}
_productionUnitOfWork.Commit();
var lotKey = result.ResultingObject.ToLotKey();
return(SyncParameters.Using(new SuccessResult <ICreateProductionBatchReturn>(new CreateProductionBatchReturn
{
ProductionBatchKey = lotKey,
InstructionNotebookKey = result.ResultingObject.InstructionNotebook.ToNotebookKey()
}), lotKey));
}
public IResult RemoveProductionBatch(string productionBatchKey)
{
if (productionBatchKey == null)
{
throw new ArgumentNullException("productionBatchKey");
}
var productionBatchKeyResult = KeyParserHelper.ParseResult <ILotKey>(productionBatchKey);
if (!productionBatchKeyResult.Success)
{
return(productionBatchKeyResult);
}
var parsedProductionBatchKey = productionBatchKeyResult.ResultingObject;
var lotKey = parsedProductionBatchKey.ToLotKey();
var removeResult = new RemoveProductionBatchConductor(_productionUnitOfWork).Execute(lotKey);
if (!removeResult.Success)
{
return(removeResult);
}
_productionUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), lotKey));
}
public IResult RemovePackSchedule(IRemovePackScheduleParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var packScheduleKeyResult = KeyParserHelper.ParseResult <IPackScheduleKey>(parameters.PackScheduleKey);
if (!packScheduleKeyResult.Success)
{
return(packScheduleKeyResult.ConvertTo <DateTime?>());
}
DateTime?packSchId;
var result = new RemovePackScheduleConductor(_productionUnitOfWork).Execute(new PackScheduleKey(packScheduleKeyResult.ResultingObject), parameters.UserToken, out packSchId);
if (!result.Success)
{
return(result.ConvertTo <DateTime?>());
}
_productionUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), packSchId));
}
public IResult RemoveLotAllowance(ILotAllowanceParameters parameters)
{
var parsedParameters = parameters.ToParsedParameters();
if (!parsedParameters.Success)
{
return(parsedParameters);
}
var result = new LotAllowancesCommand(_lotUnitOfWork).Execute(parsedParameters.ResultingObject, false);
if (!result.Success)
{
return(result);
}
if (result.State != ResultState.NoWorkRequired)
{
_lotUnitOfWork.Commit();
}
return(SyncParameters.Using(new SuccessResult(), new SynchronizeLotParameters
{
LotKey = parsedParameters.ResultingObject.LotKey,
UpdateSerializationOnly = true
}));
}
public IResult <ILotStatInfoReturn> SetLotQualityStatus(ISetLotStatusParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parsedParameters = parameters.ToParsedParameters();
if (!parsedParameters.Success)
{
return(parsedParameters.ConvertTo <ILotStatInfoReturn>());
}
var result = new SetLotStatusConductor(_lotUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, parsedParameters.ResultingObject);
if (!result.Success)
{
return(result.ConvertTo <ILotStatInfoReturn>());
}
_lotUnitOfWork.Commit();
var synchronizeLotParameters = new SynchronizeLotParameters
{
LotKey = parsedParameters.ResultingObject.LotKey,
OverrideOldContextLotAsCompleted = false
};
return(SyncParameters.Using(new SuccessResult <ILotStatInfoReturn>(new LotStatInfoReturn(synchronizeLotParameters)), synchronizeLotParameters));
}
public IResult UpdateIntraWarehouseOrder(IUpdateIntraWarehouseOrderParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var keyResult = KeyParserHelper.ParseResult <IIntraWarehouseOrderKey>(parameters.IntraWarehouseOrderKey);
if (!keyResult.Success)
{
return(keyResult);
}
var updateResult = new IntraWarehouseOrderConductor(_intraWarehouseOrderUnitOfWork).Update(_timeStamper.CurrentTimeStamp, keyResult.ResultingObject, parameters);
if (!updateResult.Success)
{
return(updateResult);
}
_intraWarehouseOrderUnitOfWork.Commit();
var key = keyResult.ResultingObject.ToIntraWarehouseOrderKey();
return(SyncParameters.Using(new SuccessResult <string>(key), key));
}
public IResult <ISampleOrderJournalEntryReturn> SetJournalEntry(ISetSampleOrderJournalEntryParameters parameters)
{
var parsedParameters = parameters.ToParsedParameters();
if (!parsedParameters.Success)
{
return(parsedParameters.ConvertTo <ISampleOrderJournalEntryReturn>());
}
var result = new SetSampleJournalEntryCommand(_sampleOrderUnitOfWork).Execute(parsedParameters.ResultingObject);
if (!result.Success)
{
return(result.ConvertTo <ISampleOrderJournalEntryReturn>());
}
_sampleOrderUnitOfWork.Commit();
var journalEntry = _sampleOrderUnitOfWork.SampleOrderJournalEntryRepository.Filter(result.ResultingObject.ToSampleOrderJournalEntryKey().FindByPredicate)
.Select(SampleOrderJournalEntryProjectors.Select().ExpandAll())
.FirstOrDefault();
return(SyncParameters.Using(new SuccessResult <ISampleOrderJournalEntryReturn>(journalEntry),
new SyncSampleOrderParameters {
SampleOrderKey = result.ResultingObject.ToSampleOrderKey()
}));
}
public IResult <string> CreateInventoryTreatmentOrder(ICreateTreatmentOrderParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parsedParameters = new CreateTreatmentOrderConductorParameters <ICreateTreatmentOrderParameters>(parameters);
if (!parsedParameters.Result.Success)
{
return(parsedParameters.Result.ConvertTo <string>());
}
var createResult = new CreateTreatmentOrderConductor(_inventoryShipmentOrderUnitOfWork).CreateTreatmentOrder(_timeStamper.CurrentTimeStamp, parsedParameters);
if (!createResult.Success)
{
return(createResult.ConvertTo <string>());
}
_inventoryShipmentOrderUnitOfWork.Commit();
var key = createResult.ResultingObject.ToInventoryShipmentOrderKey();
return(SyncParameters.Using(new SuccessResult <string>(key), new SyncInventoryShipmentOrderParameters
{
InventoryShipmentOrderKey = key,
New = true
}));
}
public IResult <string> SetSalesQuote(ISalesQuoteParameters parameters, bool updateExisting)
{
var parsedParameters = parameters.ToParsedParameters(updateExisting);
if (!parsedParameters.Success)
{
return(parsedParameters.ConvertTo <string>());
}
var result = new SetSalesQuoteConductor(_inventoryShipmentOrderUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, parsedParameters.ResultingObject);
if (!result.Success)
{
return(result.ConvertTo <string>());
}
_inventoryShipmentOrderUnitOfWork.Commit();
var salesQuoteKey = result.ResultingObject.ToSalesQuoteKey();
return(SyncParameters.Using(new SuccessResult <string>(salesQuoteKey), new SyncSalesQuoteParameters
{
SalesQuoteKey = salesQuoteKey,
New = !updateExisting
}));
}
public IResult DeleteContact(string contactKey)
{
if(contactKey == null) { throw new ArgumentNullException("contactKey"); }
var keyResult = KeyParserHelper.ParseResult<IContactKey>(contactKey);
if(!keyResult.Success)
{
return keyResult;
}
var key = keyResult.ResultingObject.ToContactKey();
var contact = _companyUnitOfWork.ContactRepository.FindByKey(key, c => c.Addresses);
if(contact == null)
{
return new InvalidResult(string.Format(UserMessages.ContactNotFound, contactKey));
}
var addresses = contact.Addresses.ToList();
var tblContacts = addresses
.Select(a =>
{
var id = a.OldContextID;
_companyUnitOfWork.ContactAddressRepository.Remove(a);
return id;
})
.Concat(new [] { contact.OldContextID })
.ToList();
_companyUnitOfWork.ContactRepository.Remove(contact);
_companyUnitOfWork.Commit();
return SyncParameters.Using(new SuccessResult(), tblContacts);
}
public IResult SetPickedInventoryForSalesOrder(string salesOrderKey, ISetPickedInventoryParameters pickedInventory)
{
if (salesOrderKey == null)
{
throw new ArgumentNullException("salesOrderKey");
}
if (pickedInventory == null)
{
throw new ArgumentNullException("pickedInventory");
}
var orderKeyResult = KeyParserHelper.ParseResult <ISalesOrderKey>(salesOrderKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult);
}
var pickInventoryResult = new SetSalesOrderPickedInventoryConductor(_inventoryShipmentOrderUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, orderKeyResult.ResultingObject, pickedInventory);
if (!pickInventoryResult.Success)
{
return(pickInventoryResult);
}
_inventoryShipmentOrderUnitOfWork.Commit();
var key = pickInventoryResult.ResultingObject.ToSalesOrderKey();
return(SyncParameters.Using(new SuccessResult(), new SyncSalesOrderParameters
{
SalesOrderKey = key,
New = false
}));
}
public IResult PostInvoice(string customerOrderKey)
{
var orderKeyResult = KeyParserHelper.ParseResult <ISalesOrderKey>(customerOrderKey);
if (!orderKeyResult.Success)
{
return(orderKeyResult);
}
var orderKey = orderKeyResult.ResultingObject.ToSalesOrderKey();
var order = _inventoryShipmentOrderUnitOfWork.SalesOrderRepository.FindByKey(orderKey,
o => o.InventoryShipmentOrder.ShipmentInformation);
if (order == null)
{
return(new InvalidResult(string.Format(UserMessages.SalesOrderNotFound, orderKey)));
}
if (order.InventoryShipmentOrder.ShipmentInformation.Status != ShipmentStatus.Shipped)
{
return(new InvalidResult(string.Format(UserMessages.SalesOrderNotShipped, orderKey)));
}
order.InvoiceDate = order.InvoiceDate ?? DateTime.Now.ToLocalTime().Date;
order.OrderStatus = SalesOrderStatus.Invoiced;
_inventoryShipmentOrderUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), orderKey));
}
public IResult UpdateLocation(IUpdateLocationParameters parameters)
{
var parameterResult = parameters.ToParsedParameters();
if (!parameterResult.Success)
{
return(parameterResult);
}
var employeeResult = new GetEmployeeCommand(_facilityUnitOfWork).GetEmployee(parameters);
if (!employeeResult.Success)
{
return(employeeResult.ConvertTo <string>());
}
var result = new UpdateLocationCommand(_facilityUnitOfWork).UpdateLocation(parameterResult.ResultingObject);
if (!result.Success)
{
return(result);
}
_facilityUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new SyncLocationsParameters
{
EmployeeKey = employeeResult.ResultingObject,
Locations = new List <ILocationKey>
{
parameterResult.ResultingObject.LocationKey
}
}));
}
public IResult UpdateSalesOrder(IUpdateSalesOrderParameters parameters)
{
var parsedParametersResult = parameters.ToParsedParameters();
if (!parsedParametersResult.Success)
{
return(parsedParametersResult);
}
var updateResult = new UpdateSalesOrderConductor(_inventoryShipmentOrderUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, parsedParametersResult.ResultingObject);
if (!updateResult.Success)
{
return(updateResult);
}
_inventoryShipmentOrderUnitOfWork.Commit();
var salesOrderKey = updateResult.ResultingObject.ToSalesOrderKey();
return(SyncParameters.Using(new SuccessResult <string>(salesOrderKey), new SyncSalesOrderParameters
{
SalesOrderKey = salesOrderKey,
New = false
}));
}
public IResult <INoteReturn> AddNote(string notebookKey, ICreateNoteParameters parameters)
{
if (notebookKey == null)
{
throw new ArgumentNullException("notebookKey");
}
var keyResult = KeyParserHelper.ParseResult <INotebookKey>(notebookKey);
if (!keyResult.Success)
{
return(keyResult.ConvertTo <INoteReturn>());
}
var key = new NotebookKey(keyResult.ResultingObject);
var createNoteResult = new CreateNoteCommand(_notebookUnitOfWork).Execute(key, _timeStamper.CurrentTimeStamp, parameters);
if (!createNoteResult.Success)
{
return(createNoteResult.ConvertTo <INoteReturn>());
}
_notebookUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult <INoteReturn>(new[] { createNoteResult.ResultingObject }.Select(NoteProjectors.Select().Compile()).FirstOrDefault()), key));
}
public IResult UpdateInventoryTreatmentOrder(IUpdateTreatmentOrderParameters parameters)
{
var parsedParameters = new UpdateTreatmentOrderConductorParameters <IUpdateTreatmentOrderParameters>(parameters);
if (!parsedParameters.Result.Success)
{
return(parsedParameters.Result.ConvertTo <InventoryShipmentOrderKey>());
}
var updateResult = new UpdateTreatmentOrderConductor(_inventoryShipmentOrderUnitOfWork).Update(_timeStamper.CurrentTimeStamp, parsedParameters);
if (!updateResult.Success)
{
return(updateResult.ConvertTo <InventoryShipmentOrderKey>());
}
_inventoryShipmentOrderUnitOfWork.Commit();
var key = updateResult.ResultingObject.ToInventoryShipmentOrderKey();
return(SyncParameters.Using(new SuccessResult <string>(key), new SyncInventoryShipmentOrderParameters
{
InventoryShipmentOrderKey = key,
New = false
}));
}
public IResult UpdateNote(string noteKey, IUpdateNoteParameters parameters)
{
if (noteKey == null)
{
throw new ArgumentNullException("noteKey");
}
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var keyResult = KeyParserHelper.ParseResult <INoteKey>(noteKey);
if (!keyResult.Success)
{
return(keyResult);
}
var parsedNoteKey = new NoteKey(keyResult.ResultingObject);
var updateNoteResult = new UpdateNoteCommand(_notebookUnitOfWork).Execute(parsedNoteKey, _timeStamper.CurrentTimeStamp, parameters);
if (!updateNoteResult.Success)
{
return(updateNoteResult);
}
_notebookUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new NotebookKey(parsedNoteKey)));
}
public IResult DeleteNote(string noteKey)
{
if (noteKey == null)
{
throw new ArgumentNullException("noteKey");
}
var keyResult = KeyParserHelper.ParseResult <INoteKey>(noteKey);
if (!keyResult.Success)
{
return(keyResult);
}
var key = new NoteKey(keyResult.ResultingObject);
var note = _notebookUnitOfWork.NoteRepository.FindByKey(key);
if (note == null)
{
return(new InvalidResult(string.Format(UserMessages.NoteNotFound, noteKey)));
}
_notebookUnitOfWork.NoteRepository.Remove(note);
_notebookUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new NotebookKey(key)));
}
public IResult DeleteJournalEntry(string journalEntryKey)
{
var keyResult = KeyParserHelper.ParseResult <ISampleOrderJournalEntryKey>(journalEntryKey);
if (!keyResult.Success)
{
return(keyResult);
}
var journalEntry = _sampleOrderUnitOfWork.SampleOrderJournalEntryRepository.FindByKey(keyResult.ResultingObject.ToSampleOrderJournalEntryKey());
if (journalEntry == null)
{
return(new NoWorkRequiredResult());
}
var sampleOrderKey = journalEntry.ToSampleOrderKey();
_sampleOrderUnitOfWork.SampleOrderJournalEntryRepository.Remove(journalEntry);
_sampleOrderUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new SyncSampleOrderParameters {
SampleOrderKey = sampleOrderKey
}));
}
public IResult <ICreateLotDefectReturn> CreateLotDefect(ICreateLotDefectParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parsedParameters = parameters.ToParsedParameters();
if (!parsedParameters.Success)
{
return(parsedParameters.ConvertTo <ICreateLotDefectReturn>());
}
var createDefectResult = new CreateInHouseContaminationDefectCommand(_lotUnitOfWork).Execute(parsedParameters.ResultingObject, _timeStamper.CurrentTimeStamp);
if (!createDefectResult.Success)
{
return(createDefectResult.ConvertTo <ICreateLotDefectReturn>());
}
_lotUnitOfWork.Commit();
var synchronizeLotParameters = new SynchronizeLotParameters
{
LotKey = parsedParameters.ResultingObject.LotKey,
OverrideOldContextLotAsCompleted = false
};
return(SyncParameters.Using(new SuccessResult <ICreateLotDefectReturn>(
new CreateLotDefectReturn(createDefectResult.ResultingObject.ToLotDefectKey(), synchronizeLotParameters)),
synchronizeLotParameters));
}
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 SetInterWarehouseOrderPickedInventoryConductor(_inventoryShipmentOrderUnitOfWork)
.UpdatePickedInventory(orderKey, parameters, _timeStamper.CurrentTimeStamp, parsedParameters.ResultingObject);
if (!setResult.Success)
{
return(setResult);
}
_inventoryShipmentOrderUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), new SyncInventoryShipmentOrderParameters
{
InventoryShipmentOrderKey = orderKey,
New = false
}));
}
public IResult <string> CreateProductionBatchResults(ICreateProductionBatchResultsParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parametersResult = parameters.ToParsedParameters();
if (!parametersResult.Success)
{
return(parametersResult.ConvertTo <string>());
}
var createResult = new ProductionBatchResultsConductor(_productionUnitOfWork).Create(_timeStamper.CurrentTimeStamp, parametersResult.ResultingObject);
if (!createResult.Success)
{
return(createResult.ConvertTo <string>());
}
_productionUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult <string>(parametersResult.ResultingObject.LotKey), parametersResult.ResultingObject.LotKey));
}
public IResult <string> UpdateCustomerContract(IUpdateCustomerContractParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parsedParametersResult = parameters.ToParsedParameters();
if (!parsedParametersResult.Success)
{
return(parsedParametersResult.ConvertTo <string>());
}
var commandResult = new UpdateCustomerContractConductor(_inventoryShipmentOrderUnitOfWork).Execute(parsedParametersResult.ResultingObject, _timeStamper.CurrentTimeStamp);
if (!commandResult.Success)
{
return(commandResult.ConvertTo <string>());
}
_inventoryShipmentOrderUnitOfWork.Commit();
var contractKey = commandResult.ResultingObject.ToContractKey();
return(SyncParameters.Using(new SuccessResult <string>(contractKey), new SyncCustomerContractParameters
{
ContractKey = contractKey,
New = false
}));
}
public IResult UpdateProductionBatchResults(IUpdateProductionBatchResultsParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parsedParameters = parameters.ToParsedParameters();
if (!parsedParameters.Success)
{
return(parsedParameters);
}
var updateResult = new ProductionBatchResultsConductor(_productionUnitOfWork).Update(_timeStamper.CurrentTimeStamp, parsedParameters.ResultingObject);
if (!updateResult.Success)
{
return(updateResult);
}
_productionUnitOfWork.Commit();
return(SyncParameters.Using(new SuccessResult(), parsedParameters.ResultingObject.LotKey));
}
public IResult <string> CreateSalesOrder(ICreateSalesOrderParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parsedParametersResult = parameters.ToParsedParameters();
if (!parsedParametersResult.Success)
{
return(parsedParametersResult.ConvertTo <string>());
}
var conductorResult = new CreateSalesOrderConductor(_inventoryShipmentOrderUnitOfWork).Execute(_timeStamper.CurrentTimeStamp, parsedParametersResult.ResultingObject);
if (!conductorResult.Success)
{
return(conductorResult.ConvertTo <string>());
}
_inventoryShipmentOrderUnitOfWork.Commit();
var salesOrderKey = conductorResult.ResultingObject.ToSalesOrderKey();
return(SyncParameters.Using(new SuccessResult <string>(salesOrderKey), new SyncSalesOrderParameters
{
SalesOrderKey = salesOrderKey,
New = true
}));
}
public IResult AddLotAttributes(IAddLotAttributesParameters parameters)
{
if (parameters == null)
{
throw new ArgumentNullException("parameters");
}
var parsedParameters = parameters.ToParsedParameters();
if (!parsedParameters.Success)
{
return(parsedParameters);
}
var setAttributesResult = new SetLotAttributesConductor(_lotUnitOfWork).AddLotAttributes(_timeStamper.CurrentTimeStamp, parsedParameters.ResultingObject);
if (!setAttributesResult.Success)
{
return(setAttributesResult);
}
_lotUnitOfWork.Commit();
var syncParameters = new SynchronizeLotParameters
{
LotKeys = parsedParameters.ResultingObject.LotKeys,
OverrideOldContextLotAsCompleted = parameters.OverrideOldContextLotAsCompleted
};
return(SyncParameters.Using(new SuccessResult <ILotStatInfoReturn>(new LotStatInfoReturn(syncParameters)), syncParameters));
}
/// <summary>
/// Retrives sync properties.
/// </summary>
/// <param name="Sync">Sync object to query.</param>
/// <param name="pname">Name of parameter to retrive.</param>
/// <param name="Length">How many ints was written to values?</param>
/// <param name="values">Prealloceted array with enough space to store result of query.</param>
public static void GetSynciv(IntPtr Sync, SyncParameters pname, out int Length, int[] values)
{
Delegates.glGetSynciv(Sync, pname, values.Length, out Length, ref values[0]);
}
