private decimal GetOutputQuantity(IInventoryPostingRuleState pr, IInventoryItemEntryStateCreated sourceEntry)
{
var accountName = pr.TriggerAccountName;
decimal srcAmount = Convert.ToDecimal(ReflectUtils.GetPropertyValue(accountName, sourceEntry));
return(pr.IsOutputNegated ? -srcAmount : srcAmount);
}
protected virtual IInventoryItemEntryStateCreated MapCreate(ICreateInventoryItemEntry c, IInventoryItemCommand outerCommand, long version, IInventoryItemState outerState)
{
c.RequesterId = outerCommand.RequesterId;
var stateEventId = new InventoryItemEntryEventId(c.InventoryItemId, c.EntrySeqId, version);
IInventoryItemEntryStateCreated e = NewInventoryItemEntryStateCreated(stateEventId);
var s = outerState.Entries.Get(c.EntrySeqId, true);
e.OnHandQuantity = c.OnHandQuantity;
e.InTransitQuantity = c.InTransitQuantity;
e.ReservedQuantity = c.ReservedQuantity;
e.OccupiedQuantity = c.OccupiedQuantity;
e.VirtualQuantity = c.VirtualQuantity;
e.Source = c.Source;
e.CreatedBy = (string)c.RequesterId;
e.CreatedAt = ApplicationContext.Current.TimestampService.Now <DateTime>();
return(e);
}// END Map(ICreate... ////////////////////////////
public virtual void When(IInventoryItemEntryStateCreated e)
{
ThrowOnWrongEvent(e);
this.OnHandQuantity = (e.OnHandQuantity != null && e.OnHandQuantity.HasValue) ? e.OnHandQuantity.Value : default(decimal);
this.InTransitQuantity = (e.InTransitQuantity != null && e.InTransitQuantity.HasValue) ? e.InTransitQuantity.Value : default(decimal);
this.ReservedQuantity = (e.ReservedQuantity != null && e.ReservedQuantity.HasValue) ? e.ReservedQuantity.Value : default(decimal);
this.OccupiedQuantity = (e.OccupiedQuantity != null && e.OccupiedQuantity.HasValue) ? e.OccupiedQuantity.Value : default(decimal);
this.VirtualQuantity = (e.VirtualQuantity != null && e.VirtualQuantity.HasValue) ? e.VirtualQuantity.Value : default(decimal);
this.Source = e.Source;
this.Deleted = false;
this.CreatedBy = e.CreatedBy;
this.CreatedAt = e.CreatedAt;
}
protected virtual IInventoryItemStateCreated Map(ICreateInventoryItem c)
{
var stateEventId = new InventoryItemEventId(c.InventoryItemId, c.Version);
IInventoryItemStateCreated e = NewInventoryItemStateCreated(stateEventId);
e.CommandId = c.CommandId;
e.CreatedBy = (string)c.RequesterId;
e.CreatedAt = ApplicationContext.Current.TimestampService.Now <DateTime>();
var version = c.Version;
decimal onHandQuantity = default(decimal);
decimal inTransitQuantity = default(decimal);
decimal reservedQuantity = default(decimal);
decimal occupiedQuantity = default(decimal);
decimal virtualQuantity = default(decimal);
foreach (ICreateInventoryItemEntry innerCommand in c.Entries)
{
ThrowOnInconsistentCommands(c, innerCommand);
IInventoryItemEntryStateCreated innerEvent = MapCreate(innerCommand, c, version, _state);
e.AddInventoryItemEntryEvent(innerEvent);
onHandQuantity = onHandQuantity + (innerEvent.OnHandQuantity != null ? innerEvent.OnHandQuantity.GetValueOrDefault() : default(decimal));
inTransitQuantity = inTransitQuantity + (innerEvent.InTransitQuantity != null ? innerEvent.InTransitQuantity.GetValueOrDefault() : default(decimal));
reservedQuantity = reservedQuantity + (innerEvent.ReservedQuantity != null ? innerEvent.ReservedQuantity.GetValueOrDefault() : default(decimal));
occupiedQuantity = occupiedQuantity + (innerEvent.OccupiedQuantity != null ? innerEvent.OccupiedQuantity.GetValueOrDefault() : default(decimal));
virtualQuantity = virtualQuantity + (innerEvent.VirtualQuantity != null ? innerEvent.VirtualQuantity.GetValueOrDefault() : default(decimal));
}
e.OnHandQuantity = onHandQuantity;
e.InTransitQuantity = inTransitQuantity;
e.ReservedQuantity = reservedQuantity;
e.OccupiedQuantity = occupiedQuantity;
e.VirtualQuantity = virtualQuantity;
return(e);
}
void IInventoryItemEntryState.When(IInventoryItemEntryStateCreated e)
{
throw new NotSupportedException();
}
public virtual InventoryItemEntryStateCreatedDto ToInventoryItemEntryStateCreatedDto(IInventoryItemEntryStateCreated e)
{
var dto = new InventoryItemEntryStateCreatedDto();
dto.InventoryItemEntryEventId = e.InventoryItemEntryEventId;
dto.CreatedAt = e.CreatedAt;
dto.CreatedBy = e.CreatedBy;
dto.Version = e.Version;
dto.CommandId = e.CommandId;
dto.OnHandQuantity = e.OnHandQuantity;
dto.InTransitQuantity = e.InTransitQuantity;
dto.ReservedQuantity = e.ReservedQuantity;
dto.OccupiedQuantity = e.OccupiedQuantity;
dto.VirtualQuantity = e.VirtualQuantity;
dto.Source = e.Source;
return(dto);
}
// ///////////////////////////////////
private InventoryPRTriggeredId GetOrCreateInventoryPRTriggered(IInventoryPostingRuleState pr, IInventoryItemEntryStateCreated iie)
{
var createTriggered = new CreateInventoryPRTriggered();
var sourceEntryId = new InventoryItemEntryId(iie.InventoryItemEntryEventId.InventoryItemId, iie.InventoryItemEntryEventId.EntrySeqId);
string postingRuleId = pr.InventoryPostingRuleId;
var tid = new InventoryPRTriggeredId(sourceEntryId, postingRuleId);
createTriggered.InventoryPRTriggeredId = tid;
createTriggered.CommandId = Guid.NewGuid().ToString();
createTriggered.IsProcessed = true; // now we use database strong consistency!
InventoryPRTriggeredApplicationService.When(createTriggered);
return(tid); //todo If existed??
}
public virtual void AddInventoryItemEntryEvent(IInventoryItemEntryStateCreated e)
{
ThrowOnInconsistentEventIds(e);
this._inventoryItemEntryEvents[e.InventoryItemEntryEventId] = e;
}
void IInventoryItemStateCreated.AddInventoryItemEntryEvent(IInventoryItemEntryStateCreated e)
{
this._inventoryItemEntryEvents.AddInventoryItemEntryEvent(e);
}
