protected void ThrowOnWrongEvent(IAttributeSetInstanceExtensionFieldStateEvent stateEvent)
        {
            var stateEntityIdGroupId = (this as IGlobalIdentity <AttributeSetInstanceExtensionFieldId>).GlobalId.GroupId;
            var eventEntityIdGroupId = stateEvent.StateEventId.GroupId;

            if (stateEntityIdGroupId != eventEntityIdGroupId)
            {
                throw DomainError.Named("mutateWrongEntity", "Entity Id GroupId {0} in state but entity id GroupId {1} in event", stateEntityIdGroupId, eventEntityIdGroupId);
            }

            var stateEntityIdIndex = (this as IGlobalIdentity <AttributeSetInstanceExtensionFieldId>).GlobalId.Index;
            var eventEntityIdIndex = stateEvent.StateEventId.Index;

            if (stateEntityIdIndex != eventEntityIdIndex)
            {
                throw DomainError.Named("mutateWrongEntity", "Entity Id Index {0} in state but entity id Index {1} in event", stateEntityIdIndex, eventEntityIdIndex);
            }

            var stateVersion = this.Version;
            var eventVersion = stateEvent.Version;

            if (AttributeSetInstanceExtensionFieldState.VersionZero == eventVersion)
            {
                eventVersion = stateEvent.Version = stateVersion;
            }
            if (stateVersion != eventVersion)
            {
                throw DomainError.Named("concurrencyConflict", "Conflict between state version {0} and event version {1}", stateVersion, eventVersion);
            }
        }
        public void Save(IAttributeSetInstanceExtensionFieldStateEvent stateEvent)
        {
            CurrentSession.Save(stateEvent);
            var saveable = stateEvent as ISaveable;

            if (saveable != null)
            {
                saveable.Save();
            }
        }
Exemplo n.º 3
0
        protected void ThrowOnWrongEvent(IAttributeSetInstanceExtensionFieldStateEvent stateEvent)
        {
            var id = new System.Text.StringBuilder();

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

            var stateEntityIdGroupId = (this as IGlobalIdentity <AttributeSetInstanceExtensionFieldId>).GlobalId.GroupId;
            var eventEntityIdGroupId = stateEvent.StateEventId.GroupId;

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

            var stateEntityIdIndex = (this as IGlobalIdentity <AttributeSetInstanceExtensionFieldId>).GlobalId.Index;
            var eventEntityIdIndex = stateEvent.StateEventId.Index;

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

            id.Append("]");

            if (ForReapplying)
            {
                return;
            }
            var stateVersion = this.Version;
            var eventVersion = stateEvent.Version;

            if (AttributeSetInstanceExtensionFieldState.VersionZero == eventVersion)
            {
                eventVersion = stateEvent.Version = stateVersion;
            }
            if (stateVersion != eventVersion)
            {
                throw OptimisticConcurrencyException.Create(stateVersion, eventVersion, id.ToString());
            }
        }
        protected virtual IAttributeSetInstanceExtensionFieldGroupStateMergePatched Map(IMergePatchAttributeSetInstanceExtensionFieldGroup c)
        {
            var stateEventId = new AttributeSetInstanceExtensionFieldGroupStateEventId(c.Id, c.Version);
            IAttributeSetInstanceExtensionFieldGroupStateMergePatched e = NewAttributeSetInstanceExtensionFieldGroupStateMergePatched(stateEventId);

            e.FieldType   = c.FieldType;
            e.FieldLength = c.FieldLength;
            e.FieldCount  = c.FieldCount;
            e.NameFormat  = c.NameFormat;
            e.Description = c.Description;
            e.Active      = c.Active;
            e.IsPropertyFieldTypeRemoved   = c.IsPropertyFieldTypeRemoved;
            e.IsPropertyFieldLengthRemoved = c.IsPropertyFieldLengthRemoved;
            e.IsPropertyFieldCountRemoved  = c.IsPropertyFieldCountRemoved;
            e.IsPropertyNameFormatRemoved  = c.IsPropertyNameFormatRemoved;
            e.IsPropertyDescriptionRemoved = c.IsPropertyDescriptionRemoved;
            e.IsPropertyActiveRemoved      = c.IsPropertyActiveRemoved;

            ReflectUtils.CopyPropertyValue("CommandId", c, e);


            e.CreatedBy = (string)c.RequesterId;
            e.CreatedAt = DateTime.Now;

            var version = c.Version;

            foreach (IAttributeSetInstanceExtensionFieldCommand innerCommand in c.AttributeSetInstanceExtensionFieldCommands)
            {
                ThrowOnInconsistentCommands(c, innerCommand);

                IAttributeSetInstanceExtensionFieldStateEvent innerEvent = Map(innerCommand, c, version, _state);
                e.AddAttributeSetInstanceExtensionFieldEvent(innerEvent);
            }


            return(e);
        }
Exemplo n.º 5
0
 public void AddAttributeSetInstanceExtensionFieldEvent(IAttributeSetInstanceExtensionFieldStateEvent e)
 {
     _innerStateEvents.Add((AttributeSetInstanceExtensionFieldStateCreatedOrMergePatchedOrRemovedDto)e);
 }
Exemplo n.º 6
0
 public virtual void AddAttributeSetInstanceExtensionFieldEvent(IAttributeSetInstanceExtensionFieldStateEvent e)
 {
     ThrowOnInconsistentEventIds(e);
     this._attributeSetInstanceExtensionFieldEvents[e.StateEventId] = e;
 }
Exemplo n.º 7
0
 public static void ThrowOnInconsistentEventIds(IAttributeSetInstanceExtensionFieldGroupStateEvent oe, IAttributeSetInstanceExtensionFieldStateEvent e)
 {
     if (!oe.StateEventId.Id.Equals(e.StateEventId.GroupId))
     {
         throw DomainError.Named("inconsistentEventIds", "Outer Id Id {0} but inner id GroupId {1}",
                                 oe.StateEventId.Id, e.StateEventId.GroupId);
     }
 }
Exemplo n.º 8
0
 protected void ThrowOnInconsistentEventIds(IAttributeSetInstanceExtensionFieldStateEvent e)
 {
     ThrowOnInconsistentEventIds(this, e);
 }
 void IAttributeSetInstanceExtensionFieldGroupStateMergePatched.AddAttributeSetInstanceExtensionFieldEvent(IAttributeSetInstanceExtensionFieldStateEvent e)
 {
     this._attributeSetInstanceExtensionFieldEvents.AddAttributeSetInstanceExtensionFieldEvent(e);
 }
        public virtual AttributeSetInstanceExtensionFieldStateCreatedOrMergePatchedOrRemovedDto ToAttributeSetInstanceExtensionFieldStateEventDto(IAttributeSetInstanceExtensionFieldStateEvent stateEvent)
        {
            if (stateEvent.StateEventType == StateEventType.Created)
            {
                var e = (IAttributeSetInstanceExtensionFieldStateCreated)stateEvent;
                return(ToAttributeSetInstanceExtensionFieldStateCreatedDto(e));
            }
            else if (stateEvent.StateEventType == StateEventType.MergePatched)
            {
                var e = (IAttributeSetInstanceExtensionFieldStateMergePatched)stateEvent;
                return(ToAttributeSetInstanceExtensionFieldStateMergePatchedDto(e));
            }
            else if (stateEvent.StateEventType == StateEventType.Removed)
            {
                var e = (IAttributeSetInstanceExtensionFieldStateRemoved)stateEvent;
                return(ToAttributeSetInstanceExtensionFieldStateRemovedDto(e));
            }

            throw DomainError.Named("invalidStateEventType", String.Format("Invalid state event type: {0}", stateEvent.StateEventType));
        }