public override EventStream LoadEventStream(Type eventType, IEventStoreAggregateId eventStoreAggregateId, long version)
{
Type supportedEventType = typeof(UserClaimMvoEventBase);
if (!eventType.IsAssignableFrom(supportedEventType))
{
throw new NotSupportedException();
}
UserClaimId idObj = (UserClaimId)(eventStoreAggregateId as EventStoreAggregateId).Id;
var criteria = CurrentSession.CreateCriteria <UserClaimMvoEventBase>();
criteria.Add(Restrictions.Eq("UserClaimMvoEventId.UserClaimIdUserId", idObj.UserId));
criteria.Add(Restrictions.Eq("UserClaimMvoEventId.UserClaimIdClaimId", idObj.ClaimId));
criteria.Add(Restrictions.Le("UserClaimMvoEventId.UserVersion", version));
criteria.AddOrder(global::NHibernate.Criterion.Order.Asc("UserClaimMvoEventId.UserVersion"));
var es = criteria.List <IEvent>();
foreach (UserClaimMvoEventBase e in es)
{
e.EventReadOnly = true;
}
return(new EventStream()
{
SteamVersion = es.Count > 0 ? ((UserClaimMvoEventBase)es.Last()).UserClaimMvoEventId.UserVersion : default(long),
Events = es
});
}
public static string ToIdString(UserClaimId id)
{
var formatter = new UserClaimIdFlattenedDtoFormatter();
var idDto = new UserClaimIdFlattenedDto(id);
var idStr = formatter.ToString(idDto);
return(idStr);
}
public IUserClaimMvoState Get(UserClaimId id)
{
IUserClaimMvoState state = CurrentSession.Get <UserClaimMvoState>(id);
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IUserClaimMvoState>(state, new Type[] { }, _readOnlyPropertyNames));
}
return(state);
}
public IUserClaimState Get(UserClaimId id)
{
IUserClaimState state = CurrentSession.Get <UserClaimState>(id);
if (state == null)
{
state = new UserClaimState();
(state as UserClaimState).UserClaimId = id;
}
return(state);
}
public async Task <IUserClaimMvoStateEvent> GetStateEventAsync(UserClaimId userClaimId, long version)
{
var idObj = UserClaimMvoProxyUtils.ToIdString(userClaimId);
var uriParameters = new UserClaimMvoStateEventUriParameters();
uriParameters.Id = idObj;
uriParameters.Version = version.ToString();
var req = new UserClaimMvoStateEventGetRequest(uriParameters);
var resp = await _ramlClient.UserClaimMvoStateEvent.Get(req);
UserClaimMvoProxyUtils.ThrowOnHttpResponseError(resp);
return(resp.Content);
}
public virtual IUserClaimMvoEvent GetEvent(UserClaimId userClaimId, long version)
{
var e = (IUserClaimMvoEvent)EventStore.GetEvent(ToEventStoreAggregateId(userClaimId), version);
if (e != null)
{
e.ReadOnly = true;
}
else if (version == -1)
{
return(GetEvent(userClaimId, 0));
}
return(e);
}
public IUserClaimState Get(UserClaimId id, bool nullAllowed)
{
IUserClaimState state = CurrentSession.Get <UserClaimState>(id);
if (!nullAllowed && state == null)
{
state = new UserClaimState();
(state as UserClaimState).UserClaimId = id;
}
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IUserClaimState>(state, new Type[] { }, _readOnlyPropertyNames));
}
return(state);
}
public async Task <IUserClaimMvoState> GetAsync(UserClaimId userClaimId)
{
IUserClaimMvoState state = null;
var idObj = UserClaimMvoProxyUtils.ToIdString(userClaimId);
var uriParameters = new UserClaimMvoUriParameters();
uriParameters.Id = idObj;
var req = new UserClaimMvoGetRequest(uriParameters);
var resp = await _ramlClient.UserClaimMvo.Get(req);
UserClaimMvoProxyUtils.ThrowOnHttpResponseError(resp);
state = resp.Content;
return(state);
}
public UserClaimMvoEventId(UserClaimId userClaimId, long userVersion)
{
this._userClaimId = userClaimId;
this._userVersion = userVersion;
}
public virtual IUserClaimState GetUserClaim(string userId, int claimId)
{
var entityId = new UserClaimId(userId, claimId);
return(CurrentSession.Get <UserClaimState>(entityId));
}
public override IEventStoreAggregateId ToEventStoreAggregateId(UserClaimId aggregateId)
{
return(new EventStoreAggregateId(aggregateId));
}
public IUserClaimMvoStateEvent GetStateEvent(UserClaimId userClaimId, long version)
{
return(GetStateEventAsync(userClaimId, version).GetAwaiter().GetResult());
}
public IUserClaimMvoState Get(UserClaimId userClaimId)
{
return(GetAsync(userClaimId).GetAwaiter().GetResult());
}
public abstract IEventStoreAggregateId ToEventStoreAggregateId(UserClaimId aggregateId);
public virtual IUserClaimMvoState GetHistoryState(UserClaimId userClaimId, long version)
{
var eventStream = EventStore.LoadEventStream(typeof(IUserClaimMvoEvent), ToEventStoreAggregateId(userClaimId), version - 1);
return(new UserClaimMvoState(eventStream.Events));
}
public virtual IUserClaimMvoState Get(UserClaimId userClaimId)
{
var state = StateRepository.Get(userClaimId, true);
return(state);
}
