public static string ToIdString(OrderItemId id)
{
var formatter = (new ValueObjectTextFormatter <OrderItemId>());
var idStr = formatter.ToString(id);
return(idStr);
}
public override EventStream LoadEventStream(Type eventType, IEventStoreAggregateId eventStoreAggregateId, long version)
{
Type supportedEventType = typeof(OrderItemMvoEventBase);
if (!eventType.IsAssignableFrom(supportedEventType))
{
throw new NotSupportedException();
}
OrderItemId idObj = (OrderItemId)(eventStoreAggregateId as EventStoreAggregateId).Id;
var criteria = CurrentSession.CreateCriteria <OrderItemMvoEventBase>();
criteria.Add(Restrictions.Eq("OrderItemMvoEventId.OrderItemIdOrderId", idObj.OrderId));
criteria.Add(Restrictions.Eq("OrderItemMvoEventId.OrderItemIdOrderItemSeqId", idObj.OrderItemSeqId));
criteria.Add(Restrictions.Le("OrderItemMvoEventId.OrderVersion", version));
criteria.AddOrder(global::NHibernate.Criterion.Order.Asc("OrderItemMvoEventId.OrderVersion"));
var es = criteria.List <IEvent>();
foreach (OrderItemMvoEventBase e in es)
{
e.EventReadOnly = true;
}
return(new EventStream()
{
SteamVersion = es.Count > 0 ? ((OrderItemMvoEventBase)es.Last()).OrderItemMvoEventId.OrderVersion : default(long),
Events = es
});
}
public ActionResult Add(AddNewOrderViewModel model)
{
Argument.ExpectNotNull(() => model);
if (ModelState.IsValid)
{
var itemId = new OrderItemId(ServiceLocator.IdentityGenerator.GenerateNewId());
var cmd = new AddProductToOrder(
model.OrderId,
itemId,
new Uri(model.ProductUrl),
model.Name,
model.Description,
model.Price.Value,
model.Quantity.Value,
model.Size,
model.Color,
String.IsNullOrEmpty(model.ImageUrl) ? null : new Uri(model.ImageUrl));
_bus.Send(cmd);
//TODO: figure out how to avoid this
Thread.Sleep(100);
return RedirectToAction("Add");
}
return View(model);
}
public OrderItem(OrderItemId id, int quantity)
{
Argument.ExpectNotNull(() => id);
Argument.Expect(() => quantity > 0, "quantity", String.Format(CultureInfo.InvariantCulture, "quantity must be a positive value, was {0}", quantity));
Id = id;
Quantity = quantity;
}
public IOrderItemMvoState Get(OrderItemId id)
{
IOrderItemMvoState state = CurrentSession.Get <OrderItemMvoState>(id);
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IOrderItemMvoState>(state, new Type[] { }, _readOnlyPropertyNames));
}
return(state);
}
public override int GetHashCode()
{
var hashCode = 2036580019;
hashCode = hashCode * -1521134295 + OrderItemId.GetHashCode();
hashCode = hashCode * -1521134295 + Num.GetHashCode();
hashCode = hashCode * -1521134295 + EqualityComparer <string> .Default.GetHashCode(name);
hashCode = hashCode * -1521134295 + price.GetHashCode();
return(hashCode);
}
public async Task <IOrderItemMvoState> GetHistoryStateAsync(OrderItemId orderItemId, long version)
{
var idObj = OrderItemMvoProxyUtils.ToIdString(orderItemId);
var uriParameters = new OrderItemMvoHistoryStateUriParameters();
uriParameters.Id = idObj;
uriParameters.Version = version.ToString();
var req = new OrderItemMvoHistoryStateGetRequest(uriParameters);
var resp = await _ramlClient.OrderItemMvoHistoryState.Get(req);
OrderItemMvoProxyUtils.ThrowOnHttpResponseError(resp);
return((resp.Content == null) ? null : resp.Content.ToOrderItemMvoState());
}
public virtual IOrderItemMvoEvent GetEvent(OrderItemId orderItemId, long version)
{
var e = (IOrderItemMvoEvent)EventStore.GetEvent(ToEventStoreAggregateId(orderItemId), version);
if (e != null)
{
e.ReadOnly = true;
}
else if (version == -1)
{
return(GetEvent(orderItemId, 0));
}
return(e);
}
public async Task <IOrderItemMvoEvent> GetStateEventAsync(OrderItemId orderItemId, long version)
{
var idObj = OrderItemMvoProxyUtils.ToIdString(orderItemId);
var uriParameters = new OrderItemMvoStateEventUriParameters();
uriParameters.Id = idObj;
uriParameters.Version = version.ToString();
var req = new OrderItemMvoStateEventGetRequest(uriParameters);
var resp = await _ramlClient.OrderItemMvoStateEvent.Get(req);
OrderItemMvoProxyUtils.ThrowOnHttpResponseError(resp);
return(resp.Content);
}
public IOrderItemMvoState Get(OrderItemId id, bool nullAllowed)
{
IOrderItemMvoState state = CurrentSession.Get <OrderItemMvoState> (id);
if (!nullAllowed && state == null)
{
state = new OrderItemMvoState();
(state as OrderItemMvoState).OrderItemId = id;
}
if (ReadOnlyProxyGenerator != null && state != null)
{
return(ReadOnlyProxyGenerator.CreateProxy <IOrderItemMvoState>(state, new Type[] { }, _readOnlyPropertyNames));
}
return(state);
}
public void AddComment(int userId, string comment)
{
if (StringUtils.IsBlank(comment))
{
throw new ArgumentException("Comment cannot be blank");
}
OrderItemComment orderItemComment = OrderItemComment.New();
orderItemComment.OrderItemId = OrderItemId.GetValueOrDefault();
orderItemComment.UserId = userId;
orderItemComment.CommentText = comment;
orderItemComment.CommentDate = DateTime.Now;
NewOrderItemCommentList.Add(orderItemComment);
}
public async Task <IOrderItemMvoState> GetAsync(OrderItemId orderItemId)
{
IOrderItemMvoState state = null;
var idObj = OrderItemMvoProxyUtils.ToIdString(orderItemId);
var uriParameters = new OrderItemMvoUriParameters();
uriParameters.Id = idObj;
var req = new OrderItemMvoGetRequest(uriParameters);
var resp = await _ramlClient.OrderItemMvo.Get(req);
OrderItemMvoProxyUtils.ThrowOnHttpResponseError(resp);
state = (resp.Content == null) ? null : resp.Content.ToOrderItemMvoState();
return(state);
}
public IOrderItemMvoEvent GetEvent(OrderItemId orderItemId, long version)
{
return(GetStateEventAsync(orderItemId, version).GetAwaiter().GetResult());
}
public virtual IOrderItemState GetOrderItem(string orderId, string orderItemSeqId)
{
var entityId = new OrderItemId(orderId, orderItemSeqId);
return(CurrentSession.Get <OrderItemState>(entityId));
}
public virtual IOrderItemMvoState GetHistoryState(OrderItemId orderItemId, long version)
{
var eventStream = EventStore.LoadEventStream(typeof(IOrderItemMvoEvent), ToEventStoreAggregateId(orderItemId), version - 1);
return(new OrderItemMvoState(eventStream.Events));
}
public abstract IEventStoreAggregateId ToEventStoreAggregateId(OrderItemId aggregateId);
public override IEventStoreAggregateId ToEventStoreAggregateId(OrderItemId aggregateId)
{
return(new EventStoreAggregateId(aggregateId));
}
public OrderItemMvoEventId(OrderItemId orderItemId, long orderVersion)
{
this._orderItemId = orderItemId;
this._orderVersion = orderVersion;
}
public virtual IOrderItemMvoState GetHistoryState(OrderItemId orderItemId, long version)
{
return(GetHistoryStateAsync(orderItemId, version).GetAwaiter().GetResult());
}
public IOrderItemMvoState Get(OrderItemId orderItemId)
{
return(GetAsync(orderItemId).GetAwaiter().GetResult());
}
public virtual IOrderItemMvoState Get(OrderItemId orderItemId)
{
var state = StateRepository.Get(orderItemId, true);
return(state);
}
