public IInventoryItemState Get(InventoryItemId id)
{
IInventoryItemState state = CurrentSession.Get <InventoryItemState>(id);
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IInventoryItemState>(state, new Type[] { typeof(ISaveable) }, _readOnlyPropertyNames));
}
return(state);
}
public DtoInventoryItemEntryStates(IInventoryItemState outerState, IEnumerable <IInventoryItemEntryState> innerStates)
{
this._outerState = outerState;
if (innerStates == null)
{
this._innerStates = new IInventoryItemEntryState[] { };
}
else
{
this._innerStates = innerStates;
}
}
public IInventoryItemState Get(InventoryItemId id, bool nullAllowed)
{
IInventoryItemState state = CurrentSession.Get <InventoryItemState> (id);
if (!nullAllowed && state == null)
{
state = new InventoryItemState();
(state as InventoryItemState).InventoryItemId = id;
}
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IInventoryItemState>(state, new Type[] { typeof(ISaveable) }, _readOnlyPropertyNames));
}
return(state);
}
public async Task <IInventoryItemState> GetAsync(InventoryItemId inventoryItemId)
{
IInventoryItemState state = null;
var idObj = InventoryItemProxyUtils.ToIdString(inventoryItemId);
var uriParameters = new InventoryItemUriParameters();
uriParameters.Id = idObj;
var req = new InventoryItemGetRequest(uriParameters);
var resp = await _ramlClient.InventoryItem.Get(req);
InventoryItemProxyUtils.ThrowOnHttpResponseError(resp);
state = (resp.Content == null) ? null : resp.Content.ToInventoryItemState();
return(state);
}
public void Save(IInventoryItemState state)
{
IInventoryItemState s = state;
if (ReadOnlyProxyGenerator != null)
{
s = ReadOnlyProxyGenerator.GetTarget <IInventoryItemState>(state);
}
CurrentSession.SaveOrUpdate(s);
var saveable = s as ISaveable;
if (saveable != null)
{
saveable.Save();
}
CurrentSession.Flush();
}
public InventoryItemEntryStates(IInventoryItemState outerState)
{
this._inventoryItemState = outerState;
this._forReapplying = outerState.ForReapplying;
}
public override IInventoryItemAggregate GetInventoryItemAggregate(IInventoryItemState state)
{
return(new InventoryItemAggregate(state));
}
protected bool IsRepeatedCommand(IInventoryItemCommand command, IEventStoreAggregateId eventStoreAggregateId, IInventoryItemState state)
{
bool repeated = false;
if (((IInventoryItemStateProperties)state).Version > command.AggregateVersion)
{
var lastEvent = EventStore.GetEvent(typeof(IInventoryItemEvent), eventStoreAggregateId, command.AggregateVersion);
if (lastEvent != null && lastEvent.CommandId == command.CommandId)
{
repeated = true;
}
}
return(repeated);
}
private void Persist(IEventStoreAggregateId eventStoreAggregateId, IInventoryItemAggregate aggregate, IInventoryItemState state)
{
EventStore.AppendEvents(eventStoreAggregateId, ((IInventoryItemStateProperties)state).Version, aggregate.Changes, () => { StateRepository.Save(state); });
if (AggregateEventListener != null)
{
AggregateEventListener.EventAppended(new AggregateEvent <IInventoryItemAggregate, IInventoryItemState>(aggregate, state, aggregate.Changes));
}
}
public abstract IInventoryItemAggregate GetInventoryItemAggregate(IInventoryItemState state);
public InventoryItemStateDtoWrapper(IInventoryItemState state)
{
this._state = state;
}
public InventoryItemStateDtoWrapper()
{
this._state = new InventoryItemState();
}
public InventoryItemAggregate(IInventoryItemState state)
{
_state = state;
}
protected virtual IInventoryItemEntryStateCreated MapCreate(ICreateInventoryItemEntry c, IInventoryItemCommand outerCommand, long version, IInventoryItemState outerState)
{
c.RequesterId = outerCommand.RequesterId;
var stateEventId = new InventoryItemEntryEventId(c.InventoryItemId, c.EntrySeqId, version);
IInventoryItemEntryStateCreated e = NewInventoryItemEntryStateCreated(stateEventId);
var s = outerState.Entries.Get(c.EntrySeqId, true);
e.OnHandQuantity = c.OnHandQuantity;
e.InTransitQuantity = c.InTransitQuantity;
e.ReservedQuantity = c.ReservedQuantity;
e.OccupiedQuantity = c.OccupiedQuantity;
e.VirtualQuantity = c.VirtualQuantity;
e.Source = c.Source;
e.OccurredAt = c.OccurredAt;
e.CreatedBy = (string)c.RequesterId;
e.CreatedAt = ApplicationContext.Current.TimestampService.Now <DateTime>();
return(e);
}// END Map(ICreate... ////////////////////////////
}// END ThrowOnInconsistentCommands /////////////////////
protected virtual IInventoryItemEntryEvent Map(IInventoryItemEntryCommand c, IInventoryItemCommand outerCommand, long version, IInventoryItemState outerState)
{
var create = (c.CommandType == CommandType.Create) ? (c as ICreateInventoryItemEntry) : null;
if (create != null)
{
return(MapCreate(create, outerCommand, version, outerState));
}
throw new NotSupportedException();
}
