public static void ThrowOnInconsistentEventIds(IAttributeSetEvent oe, IAttributeUseEvent e)
{
if (!oe.AttributeSetEventId.AttributeSetId.Equals(e.AttributeUseEventId.AttributeSetId))
{
throw DomainError.Named("inconsistentEventIds", "Outer Id AttributeSetId {0} but inner id AttributeSetId {1}",
oe.AttributeSetEventId.AttributeSetId, e.AttributeUseEventId.AttributeSetId);
}
}
public void Save(IAttributeUseEvent stateEvent)
{
CurrentSession.Save(stateEvent);
var saveable = stateEvent as ISaveable;
if (saveable != null)
{
saveable.Save();
}
}
protected void ThrowOnWrongEvent(IAttributeUseEvent e)
{
var id = new System.Text.StringBuilder();
id.Append("[").Append("AttributeUse|");
var stateEntityIdAttributeSetId = (this as IGlobalIdentity <AttributeSetAttributeUseId>).GlobalId.AttributeSetId;
var eventEntityIdAttributeSetId = e.AttributeUseEventId.AttributeSetId;
if (stateEntityIdAttributeSetId != eventEntityIdAttributeSetId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id AttributeSetId {0} in state but entity id AttributeSetId {1} in event", stateEntityIdAttributeSetId, eventEntityIdAttributeSetId);
}
id.Append(stateEntityIdAttributeSetId).Append(",");
var stateEntityIdAttributeId = (this as IGlobalIdentity <AttributeSetAttributeUseId>).GlobalId.AttributeId;
var eventEntityIdAttributeId = e.AttributeUseEventId.AttributeId;
if (stateEntityIdAttributeId != eventEntityIdAttributeId)
{
throw DomainError.Named("mutateWrongEntity", "Entity Id AttributeId {0} in state but entity id AttributeId {1} in event", stateEntityIdAttributeId, eventEntityIdAttributeId);
}
id.Append(stateEntityIdAttributeId).Append(",");
id.Append("]");
if (ForReapplying)
{
return;
}
var stateVersion = this.Version;
var stateEvent = e is IAttributeUseStateEvent ? (IAttributeUseStateEvent)e : null;
if (e == null)
{
return;
}
stateEvent.Version = stateVersion;
//var stateEventStateVersion = stateEvent.Version;
//if (AttributeUseState.VersionZero == stateEventStateVersion)
//{
// stateEventStateVersion = stateEvent.Version = stateVersion;
//}
//if (stateVersion != stateEventStateVersion)
//{
// throw OptimisticConcurrencyException.Create(stateVersion, stateEventStateVersion, id.ToString());
//}
}
protected virtual IAttributeSetStateMergePatched Map(IMergePatchAttributeSet c)
{
var stateEventId = new AttributeSetEventId(c.AttributeSetId, c.Version);
IAttributeSetStateMergePatched e = NewAttributeSetStateMergePatched(stateEventId);
e.AttributeSetName = c.AttributeSetName;
e.OrganizationId = c.OrganizationId;
e.Description = c.Description;
e.ReferenceId = c.ReferenceId;
e.IsInstanceAttributeSet = c.IsInstanceAttributeSet;
e.IsMandatory = c.IsMandatory;
e.Active = c.Active;
e.IsPropertyAttributeSetNameRemoved = c.IsPropertyAttributeSetNameRemoved;
e.IsPropertyOrganizationIdRemoved = c.IsPropertyOrganizationIdRemoved;
e.IsPropertyDescriptionRemoved = c.IsPropertyDescriptionRemoved;
e.IsPropertyReferenceIdRemoved = c.IsPropertyReferenceIdRemoved;
e.IsPropertyIsInstanceAttributeSetRemoved = c.IsPropertyIsInstanceAttributeSetRemoved;
e.IsPropertyIsMandatoryRemoved = c.IsPropertyIsMandatoryRemoved;
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 (IAttributeUseCommand innerCommand in c.AttributeUseCommands)
{
ThrowOnInconsistentCommands(c, innerCommand);
IAttributeUseEvent innerEvent = Map(innerCommand, c, version, _state);
e.AddAttributeUseEvent(innerEvent);
}
return(e);
}
public void AddAttributeUseEvent(IAttributeUseEvent e)
{
_innerStateEvents.Add((AttributeUseStateCreatedOrMergePatchedOrRemovedDto)e);
}
public virtual void AddAttributeUseEvent(IAttributeUseEvent e)
{
ThrowOnInconsistentEventIds(e);
this._attributeUseEvents[e.AttributeUseEventId] = e;
}
protected void ThrowOnInconsistentEventIds(IAttributeUseEvent e)
{
ThrowOnInconsistentEventIds(this, e);
}
void IAttributeSetStateMergePatched.AddAttributeUseEvent(IAttributeUseEvent e)
{
this._attributeUseEvents.AddAttributeUseEvent(e);
}
public virtual AttributeUseStateCreatedOrMergePatchedOrRemovedDto ToAttributeUseStateEventDto(IAttributeUseEvent stateEvent)
{
if (stateEvent.EventType == StateEventType.Created)
{
var e = (IAttributeUseStateCreated)stateEvent;
return(ToAttributeUseStateCreatedDto(e));
}
else if (stateEvent.EventType == StateEventType.MergePatched)
{
var e = (IAttributeUseStateMergePatched)stateEvent;
return(ToAttributeUseStateMergePatchedDto(e));
}
else if (stateEvent.EventType == StateEventType.Removed)
{
var e = (IAttributeUseStateRemoved)stateEvent;
return(ToAttributeUseStateRemovedDto(e));
}
throw DomainError.Named("invalidEventType", String.Format("Invalid state event type: {0}", stateEvent.EventType));
}
