public static string ToIdString(AttributeAliasId id)
{
var formatter = (new ValueObjectTextFormatter <AttributeAliasId>());
var idStr = formatter.ToString(id);
return(idStr);
}
public override EventStream LoadEventStream(Type eventType, IEventStoreAggregateId eventStoreAggregateId, long version)
{
Type supportedEventType = typeof(AttributeAliasMvoEventBase);
if (!eventType.IsAssignableFrom(supportedEventType))
{
throw new NotSupportedException();
}
AttributeAliasId idObj = (AttributeAliasId)(eventStoreAggregateId as EventStoreAggregateId).Id;
var criteria = CurrentSession.CreateCriteria <AttributeAliasMvoEventBase>();
criteria.Add(Restrictions.Eq("AttributeAliasMvoEventId.AttributeAliasIdAttributeId", idObj.AttributeId));
criteria.Add(Restrictions.Eq("AttributeAliasMvoEventId.AttributeAliasIdCode", idObj.Code));
criteria.Add(Restrictions.Le("AttributeAliasMvoEventId.AttributeVersion", version));
criteria.AddOrder(global::NHibernate.Criterion.Order.Asc("AttributeAliasMvoEventId.AttributeVersion"));
var es = criteria.List <IEvent>();
foreach (AttributeAliasMvoEventBase e in es)
{
e.EventReadOnly = true;
}
return(new EventStream()
{
SteamVersion = es.Count > 0 ? ((AttributeAliasMvoEventBase)es.Last()).AttributeAliasMvoEventId.AttributeVersion : default(long),
Events = es
});
}
public IAttributeAliasMvoState Get(AttributeAliasId id)
{
IAttributeAliasMvoState state = CurrentSession.Get <AttributeAliasMvoState>(id);
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IAttributeAliasMvoState>(state, new Type[] { }, _readOnlyPropertyNames));
}
return(state);
}
public virtual IAttributeAliasMvoEvent GetEvent(AttributeAliasId attributeAliasId, long version)
{
var e = (IAttributeAliasMvoEvent)EventStore.GetEvent(ToEventStoreAggregateId(attributeAliasId), version);
if (e != null)
{
e.ReadOnly = true;
}
else if (version == -1)
{
return(GetEvent(attributeAliasId, 0));
}
return(e);
}
public async Task <IAttributeAliasMvoState> GetHistoryStateAsync(AttributeAliasId attributeAliasId, long version)
{
var idObj = AttributeAliasMvoProxyUtils.ToIdString(attributeAliasId);
var uriParameters = new AttributeAliasMvoHistoryStateUriParameters();
uriParameters.Id = idObj;
uriParameters.Version = version.ToString();
var req = new AttributeAliasMvoHistoryStateGetRequest(uriParameters);
var resp = await _ramlClient.AttributeAliasMvoHistoryState.Get(req);
AttributeAliasMvoProxyUtils.ThrowOnHttpResponseError(resp);
return((resp.Content == null) ? null : resp.Content.ToAttributeAliasMvoState());
}
public async Task <IAttributeAliasMvoEvent> GetStateEventAsync(AttributeAliasId attributeAliasId, long version)
{
var idObj = AttributeAliasMvoProxyUtils.ToIdString(attributeAliasId);
var uriParameters = new AttributeAliasMvoStateEventUriParameters();
uriParameters.Id = idObj;
uriParameters.Version = version.ToString();
var req = new AttributeAliasMvoStateEventGetRequest(uriParameters);
var resp = await _ramlClient.AttributeAliasMvoStateEvent.Get(req);
AttributeAliasMvoProxyUtils.ThrowOnHttpResponseError(resp);
return(resp.Content);
}
public IAttributeAliasMvoState Get(AttributeAliasId id, bool nullAllowed)
{
IAttributeAliasMvoState state = CurrentSession.Get <AttributeAliasMvoState> (id);
if (!nullAllowed && state == null)
{
state = new AttributeAliasMvoState();
(state as AttributeAliasMvoState).AttributeAliasId = id;
}
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IAttributeAliasMvoState>(state, new Type[] { }, _readOnlyPropertyNames));
}
return(state);
}
public async Task <IAttributeAliasMvoState> GetAsync(AttributeAliasId attributeAliasId)
{
IAttributeAliasMvoState state = null;
var idObj = AttributeAliasMvoProxyUtils.ToIdString(attributeAliasId);
var uriParameters = new AttributeAliasMvoUriParameters();
uriParameters.Id = idObj;
var req = new AttributeAliasMvoGetRequest(uriParameters);
var resp = await _ramlClient.AttributeAliasMvo.Get(req);
AttributeAliasMvoProxyUtils.ThrowOnHttpResponseError(resp);
state = (resp.Content == null) ? null : resp.Content.ToAttributeAliasMvoState();
return(state);
}
public virtual IAttributeAliasState GetAttributeAlias(string attributeId, string code)
{
var entityId = new AttributeAliasId(attributeId, code);
return(CurrentSession.Get <AttributeAliasState>(entityId));
}
public virtual IAttributeAliasMvoState Get(AttributeAliasId attributeAliasId)
{
var state = StateRepository.Get(attributeAliasId, true);
return(state);
}
public virtual IAttributeAliasMvoState GetHistoryState(AttributeAliasId attributeAliasId, long version)
{
return(GetHistoryStateAsync(attributeAliasId, version).GetAwaiter().GetResult());
}
public IAttributeAliasMvoEvent GetEvent(AttributeAliasId attributeAliasId, long version)
{
return(GetStateEventAsync(attributeAliasId, version).GetAwaiter().GetResult());
}
public IAttributeAliasMvoState Get(AttributeAliasId attributeAliasId)
{
return(GetAsync(attributeAliasId).GetAwaiter().GetResult());
}
public AttributeAliasMvoEventId(AttributeAliasId attributeAliasId, long attributeVersion)
{
this._attributeAliasId = attributeAliasId;
this._attributeVersion = attributeVersion;
}
public override IEventStoreAggregateId ToEventStoreAggregateId(AttributeAliasId aggregateId)
{
return(new EventStoreAggregateId(aggregateId));
}
public abstract IEventStoreAggregateId ToEventStoreAggregateId(AttributeAliasId aggregateId);
public virtual IAttributeAliasMvoState GetHistoryState(AttributeAliasId attributeAliasId, long version)
{
var eventStream = EventStore.LoadEventStream(typeof(IAttributeAliasMvoEvent), ToEventStoreAggregateId(attributeAliasId), version - 1);
return(new AttributeAliasMvoState(eventStream.Events));
}
