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); }