Beispiel #1
0
        protected virtual IPicklistBinStateMergePatched Map(IMergePatchPicklistBin c)
        {
            var stateEventId = new PicklistBinEventId(c.PicklistBinId, c.Version);
            IPicklistBinStateMergePatched e = NewPicklistBinStateMergePatched(stateEventId);

            e.PicklistId            = c.PicklistId;
            e.BinLocationNumber     = c.BinLocationNumber;
            e.PrimaryOrderId        = c.PrimaryOrderId;
            e.PrimaryShipGroupSeqId = c.PrimaryShipGroupSeqId;
            e.Active = c.Active;
            e.IsPropertyPicklistIdRemoved            = c.IsPropertyPicklistIdRemoved;
            e.IsPropertyBinLocationNumberRemoved     = c.IsPropertyBinLocationNumberRemoved;
            e.IsPropertyPrimaryOrderIdRemoved        = c.IsPropertyPrimaryOrderIdRemoved;
            e.IsPropertyPrimaryShipGroupSeqIdRemoved = c.IsPropertyPrimaryShipGroupSeqIdRemoved;
            e.IsPropertyActiveRemoved = c.IsPropertyActiveRemoved;

            e.CommandId = c.CommandId;


            e.CreatedBy = (string)c.RequesterId;
            e.CreatedAt = ApplicationContext.Current.TimestampService.Now <DateTime>();

            var version = c.Version;

            foreach (IPicklistItemCommand innerCommand in c.PicklistItemCommands)
            {
                ThrowOnInconsistentCommands(c, innerCommand);

                IPicklistItemEvent innerEvent = Map(innerCommand, c, version, _state);
                e.AddPicklistItemEvent(innerEvent);
            }


            return(e);
        }
Beispiel #2
0
 public static void ThrowOnInconsistentEventIds(IPicklistBinEvent oe, IPicklistItemEvent e)
 {
     if (!oe.PicklistBinEventId.PicklistBinId.Equals(e.PicklistItemEventId.PicklistBinId))
     {
         throw DomainError.Named("inconsistentEventIds", "Outer Id PicklistBinId {0} but inner id PicklistBinId {1}",
                                 oe.PicklistBinEventId.PicklistBinId, e.PicklistItemEventId.PicklistBinId);
     }
 }
Beispiel #3
0
        public void Save(IPicklistItemEvent stateEvent)
        {
            CurrentSession.Save(stateEvent);
            var saveable = stateEvent as ISaveable;

            if (saveable != null)
            {
                saveable.Save();
            }
        }
Beispiel #4
0
        protected void ThrowOnWrongEvent(IPicklistItemEvent e)
        {
            var id = new System.Text.StringBuilder();

            id.Append("[").Append("PicklistItem|");

            var stateEntityIdPicklistBinId = (this as IGlobalIdentity <PicklistBinPicklistItemId>).GlobalId.PicklistBinId;
            var eventEntityIdPicklistBinId = e.PicklistItemEventId.PicklistBinId;

            if (stateEntityIdPicklistBinId != eventEntityIdPicklistBinId)
            {
                throw DomainError.Named("mutateWrongEntity", "Entity Id PicklistBinId {0} in state but entity id PicklistBinId {1} in event", stateEntityIdPicklistBinId, eventEntityIdPicklistBinId);
            }
            id.Append(stateEntityIdPicklistBinId).Append(",");

            var stateEntityIdPicklistItemOrderShipGrpInvId = (this as IGlobalIdentity <PicklistBinPicklistItemId>).GlobalId.PicklistItemOrderShipGrpInvId;
            var eventEntityIdPicklistItemOrderShipGrpInvId = e.PicklistItemEventId.PicklistItemOrderShipGrpInvId;

            if (stateEntityIdPicklistItemOrderShipGrpInvId != eventEntityIdPicklistItemOrderShipGrpInvId)
            {
                throw DomainError.Named("mutateWrongEntity", "Entity Id PicklistItemOrderShipGrpInvId {0} in state but entity id PicklistItemOrderShipGrpInvId {1} in event", stateEntityIdPicklistItemOrderShipGrpInvId, eventEntityIdPicklistItemOrderShipGrpInvId);
            }
            id.Append(stateEntityIdPicklistItemOrderShipGrpInvId).Append(",");

            id.Append("]");

            if (ForReapplying)
            {
                return;
            }
            var stateVersion = this.Version;
            var stateEvent   = e is IPicklistItemStateEvent ? (IPicklistItemStateEvent)e : null;

            if (e == null)
            {
                return;
            }
            stateEvent.Version = stateVersion;
            //var stateEventStateVersion = stateEvent.Version;
            //if (PicklistItemState.VersionZero == stateEventStateVersion)
            //{
            //    stateEventStateVersion = stateEvent.Version = stateVersion;
            //}
            //if (stateVersion != stateEventStateVersion)
            //{
            //    throw OptimisticConcurrencyException.Create(stateVersion, stateEventStateVersion, id.ToString());
            //}
        }
Beispiel #5
0
 public virtual void AddPicklistItemEvent(IPicklistItemEvent e)
 {
     ThrowOnInconsistentEventIds(e);
     this._picklistItemEvents[e.PicklistItemEventId] = e;
 }
Beispiel #6
0
 protected void ThrowOnInconsistentEventIds(IPicklistItemEvent e)
 {
     ThrowOnInconsistentEventIds(this, e);
 }
 public void AddPicklistItemEvent(IPicklistItemEvent e)
 {
     _innerStateEvents.Add((PicklistItemStateCreatedOrMergePatchedOrRemovedDto)e);
 }
Beispiel #8
0
 void IPicklistBinStateMergePatched.AddPicklistItemEvent(IPicklistItemEvent e)
 {
     this._picklistItemEvents.AddPicklistItemEvent(e);
 }
 public virtual PicklistItemStateCreatedOrMergePatchedOrRemovedDto ToPicklistItemStateEventDto(IPicklistItemEvent stateEvent)
 {
     if (stateEvent.EventType == StateEventType.Created)
     {
         var e = (IPicklistItemStateCreated)stateEvent;
         return(ToPicklistItemStateCreatedDto(e));
     }
     else if (stateEvent.EventType == StateEventType.MergePatched)
     {
         var e = (IPicklistItemStateMergePatched)stateEvent;
         return(ToPicklistItemStateMergePatchedDto(e));
     }
     else if (stateEvent.EventType == StateEventType.Removed)
     {
         var e = (IPicklistItemStateRemoved)stateEvent;
         return(ToPicklistItemStateRemovedDto(e));
     }
     throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
 }