public IPicklistState Get(string id)
{
IPicklistState state = CurrentSession.Get <PicklistState>(id);
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IPicklistState>(state, new Type[] { typeof(ISaveable) }, _readOnlyPropertyNames));
}
return(state);
}
public static TDeletePicklist ToDeletePicklist <TDeletePicklist>(this IPicklistState state)
where TDeletePicklist : IDeletePicklist, new()
{
var cmd = new TDeletePicklist();
cmd.PicklistId = state.PicklistId;
cmd.Version = ((IPicklistStateProperties)state).Version;
return(cmd);
}
public DtoPicklistRoleStates(IPicklistState outerState, IEnumerable <IPicklistRoleState> innerStates)
{
this._outerState = outerState;
if (innerStates == null)
{
this._innerStates = new IPicklistRoleState[] { };
}
else
{
this._innerStates = innerStates;
}
}
public IPicklistState Get(string id, bool nullAllowed)
{
IPicklistState state = CurrentSession.Get <PicklistState> (id);
if (!nullAllowed && state == null)
{
state = new PicklistState();
(state as PicklistState).PicklistId = id;
}
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IPicklistState>(state, new Type[] { typeof(ISaveable) }, _readOnlyPropertyNames));
}
return(state);
}
public async Task <IPicklistState> GetAsync(string picklistId)
{
IPicklistState state = null;
var idObj = picklistId;
var uriParameters = new PicklistUriParameters();
uriParameters.Id = idObj;
var req = new PicklistGetRequest(uriParameters);
var resp = await _ramlClient.Picklist.Get(req);
PicklistProxyUtils.ThrowOnHttpResponseError(resp);
state = (resp.Content == null) ? null : resp.Content.ToPicklistState();
return(state);
}
public void Save(IPicklistState state)
{
IPicklistState s = state;
if (ReadOnlyProxyGenerator != null)
{
s = ReadOnlyProxyGenerator.GetTarget <IPicklistState>(state);
}
CurrentSession.SaveOrUpdate(s);
var saveable = s as ISaveable;
if (saveable != null)
{
saveable.Save();
}
CurrentSession.Flush();
}
public static TCreatePicklist ToCreatePicklist <TCreatePicklist, TCreatePicklistRole>(this IPicklistState state)
where TCreatePicklist : ICreatePicklist, new()
where TCreatePicklistRole : ICreatePicklistRole, new()
{
var cmd = new TCreatePicklist();
cmd.Version = ((IPicklistStateProperties)state).Version;
cmd.PicklistId = state.PicklistId;
cmd.Description = state.Description;
cmd.FacilityId = state.FacilityId;
cmd.ShipmentMethodTypeId = state.ShipmentMethodTypeId;
cmd.StatusId = state.StatusId;
cmd.PicklistDate = state.PicklistDate;
cmd.PickwaveId = state.PickwaveId;
cmd.Active = ((IPicklistStateProperties)state).Active;
foreach (var d in state.PicklistRoles)
{
var c = d.ToCreatePicklistRole <TCreatePicklistRole>();
cmd.PicklistRoles.Add(c);
}
return(cmd);
}
public static TMergePatchPicklist ToMergePatchPicklist <TMergePatchPicklist, TCreatePicklistRole, TMergePatchPicklistRole>(this IPicklistState state)
where TMergePatchPicklist : IMergePatchPicklist, new()
where TCreatePicklistRole : ICreatePicklistRole, new()
where TMergePatchPicklistRole : IMergePatchPicklistRole, new()
{
var cmd = new TMergePatchPicklist();
cmd.Version = ((IPicklistStateProperties)state).Version;
cmd.PicklistId = state.PicklistId;
cmd.Description = state.Description;
cmd.FacilityId = state.FacilityId;
cmd.ShipmentMethodTypeId = state.ShipmentMethodTypeId;
cmd.StatusId = state.StatusId;
cmd.PicklistDate = state.PicklistDate;
cmd.PickwaveId = state.PickwaveId;
cmd.Active = ((IPicklistStateProperties)state).Active;
if (state.Description == null)
{
cmd.IsPropertyDescriptionRemoved = true;
}
if (state.FacilityId == null)
{
cmd.IsPropertyFacilityIdRemoved = true;
}
if (state.ShipmentMethodTypeId == null)
{
cmd.IsPropertyShipmentMethodTypeIdRemoved = true;
}
if (state.StatusId == null)
{
cmd.IsPropertyStatusIdRemoved = true;
}
if (state.PicklistDate == null)
{
cmd.IsPropertyPicklistDateRemoved = true;
}
if (state.PickwaveId == null)
{
cmd.IsPropertyPickwaveIdRemoved = true;
}
foreach (var d in state.PicklistRoles)
{
var c = d.ToCreateOrMergePatchPicklistRole <TCreatePicklistRole, TMergePatchPicklistRole>();
cmd.PicklistRoleCommands.Add(c);
}
return(cmd);
}
public static IPicklistCommand ToCreateOrMergePatchPicklist <TCreatePicklist, TMergePatchPicklist, TCreatePicklistRole, TMergePatchPicklistRole>(this IPicklistState state)
where TCreatePicklist : ICreatePicklist, new()
where TMergePatchPicklist : IMergePatchPicklist, new()
where TCreatePicklistRole : ICreatePicklistRole, new()
where TMergePatchPicklistRole : IMergePatchPicklistRole, new()
{
bool bUnsaved = ((IPicklistState)state).IsUnsaved;
if (bUnsaved)
{
return(state.ToCreatePicklist <TCreatePicklist, TCreatePicklistRole>());
}
else
{
return(state.ToMergePatchPicklist <TMergePatchPicklist, TCreatePicklistRole, TMergePatchPicklistRole>());
}
}
protected bool IsRepeatedCommand(IPicklistCommand command, IEventStoreAggregateId eventStoreAggregateId, IPicklistState state)
{
bool repeated = false;
if (((IPicklistStateProperties)state).Version > command.AggregateVersion)
{
var lastEvent = EventStore.GetEvent(typeof(IPicklistEvent), eventStoreAggregateId, command.AggregateVersion);
if (lastEvent != null && lastEvent.CommandId == command.CommandId)
{
repeated = true;
}
}
return(repeated);
}
}// END Map(ICreate... ////////////////////////////
protected virtual IPicklistRoleStateMergePatched MapMergePatch(IMergePatchPicklistRole c, IPicklistCommand outerCommand, long version, IPicklistState outerState)
{
c.RequesterId = outerCommand.RequesterId;
var stateEventId = new PicklistRoleEventId(c.PicklistId, c.PartyRoleId, version);
IPicklistRoleStateMergePatched e = NewPicklistRoleStateMergePatched(stateEventId);
var s = outerState.PicklistRoles.Get(c.PartyRoleId);
e.Active = c.Active;
e.IsPropertyActiveRemoved = c.IsPropertyActiveRemoved;
e.CreatedBy = (string)c.RequesterId;
e.CreatedAt = ApplicationContext.Current.TimestampService.Now <DateTime>();
return(e);
}// END Map(IMergePatch... ////////////////////////////
public override IPicklistAggregate GetPicklistAggregate(IPicklistState state)
{
return(new PicklistAggregate(state));
}
public PicklistStateDtoWrapper(IPicklistState state)
{
this._state = state;
}
public PicklistStateDtoWrapper()
{
this._state = new PicklistState();
}
public PicklistAggregate(IPicklistState state)
{
_state = state;
}
public abstract IPicklistAggregate GetPicklistAggregate(IPicklistState state);
private void Persist(IEventStoreAggregateId eventStoreAggregateId, IPicklistAggregate aggregate, IPicklistState state)
{
EventStore.AppendEvents(eventStoreAggregateId, ((IPicklistStateProperties)state).Version, aggregate.Changes, () => { StateRepository.Save(state); });
if (AggregateEventListener != null)
{
AggregateEventListener.EventAppended(new AggregateEvent <IPicklistAggregate, IPicklistState>(aggregate, state, aggregate.Changes));
}
}
public PicklistRoleStates(IPicklistState outerState)
{
this._picklistState = outerState;
this._forReapplying = outerState.ForReapplying;
}
}// END ThrowOnInconsistentCommands /////////////////////
protected virtual IPicklistRoleEvent Map(IPicklistRoleCommand c, IPicklistCommand outerCommand, long version, IPicklistState outerState)
{
var create = (c.CommandType == CommandType.Create) ? (c as ICreatePicklistRole) : null;
if (create != null)
{
return(MapCreate(create, outerCommand, version, outerState));
}
var merge = (c.CommandType == CommandType.MergePatch || c.CommandType == null) ? (c as IMergePatchPicklistRole) : null;
if (merge != null)
{
return(MapMergePatch(merge, outerCommand, version, outerState));
}
var remove = (c.CommandType == CommandType.Remove) ? (c as IRemovePicklistRole) : null;
if (remove != null)
{
return(MapRemove(remove, outerCommand, version));
}
throw new NotSupportedException();
}
