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 static TDeleteOrderItemMvo ToDeleteOrderItemMvo <TDeleteOrderItemMvo>(this IOrderItemMvoState state)
            where TDeleteOrderItemMvo : IDeleteOrderItemMvo, new()
        {
            var cmd = new TDeleteOrderItemMvo();

            cmd.OrderItemId  = state.OrderItemId;
            cmd.OrderVersion = ((IOrderItemMvoStateProperties)state).OrderVersion;

            return(cmd);
        }
        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 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 void Save(IOrderItemMvoState state)
        {
            IOrderItemMvoState s = state;

            if (ReadOnlyProxyGenerator != null)
            {
                s = ReadOnlyProxyGenerator.GetTarget <IOrderItemMvoState>(state);
            }
            CurrentSession.SaveOrUpdate(s);

            var saveable = s as ISaveable;

            if (saveable != null)
            {
                saveable.Save();
            }
            CurrentSession.Flush();
        }
        public static TMergePatchOrderItemMvo ToMergePatchOrderItemMvo <TMergePatchOrderItemMvo>(this IOrderItemMvoState state)
            where TMergePatchOrderItemMvo : IMergePatchOrderItemMvo, new()
        {
            var cmd = new TMergePatchOrderItemMvo();

            cmd.OrderVersion = ((IOrderItemMvoStateProperties)state).OrderVersion;

            cmd.OrderItemId           = state.OrderItemId;
            cmd.ProductId             = state.ProductId;
            cmd.ExternalProductId     = state.ExternalProductId;
            cmd.Quantity              = state.Quantity;
            cmd.CancelQuantity        = state.CancelQuantity;
            cmd.SelectedAmount        = state.SelectedAmount;
            cmd.ExternalId            = state.ExternalId;
            cmd.OrderItemTypeId       = state.OrderItemTypeId;
            cmd.OrderItemGroupSeqId   = state.OrderItemGroupSeqId;
            cmd.IsItemGroupPrimary    = state.IsItemGroupPrimary;
            cmd.FromInventoryItemId   = state.FromInventoryItemId;
            cmd.IsPromo               = state.IsPromo;
            cmd.QuoteId               = state.QuoteId;
            cmd.QuoteItemSeqId        = state.QuoteItemSeqId;
            cmd.ShoppingListId        = state.ShoppingListId;
            cmd.ShoppingListItemSeqId = state.ShoppingListItemSeqId;
            cmd.UnitPrice             = state.UnitPrice;
            cmd.UnitListPrice         = state.UnitListPrice;
            cmd.UnitAverageCost       = state.UnitAverageCost;
            cmd.UnitRecurringPrice    = state.UnitRecurringPrice;
            cmd.IsModifiedPrice       = state.IsModifiedPrice;
            cmd.RecurringFreqUomId    = state.RecurringFreqUomId;
            cmd.ItemDescription       = state.ItemDescription;
            cmd.Comments              = state.Comments;
            cmd.CorrespondingPoId     = state.CorrespondingPoId;
            cmd.StatusId              = state.StatusId;
            cmd.SyncStatusId          = state.SyncStatusId;
            cmd.EstimatedShipDate     = state.EstimatedShipDate;
            cmd.EstimatedDeliveryDate = state.EstimatedDeliveryDate;
            cmd.AutoCancelDate        = state.AutoCancelDate;
            cmd.DontCancelSetDate     = state.DontCancelSetDate;
            cmd.DontCancelSetBy       = state.DontCancelSetBy;
            cmd.ShipBeforeDate        = state.ShipBeforeDate;
            cmd.ShipAfterDate         = state.ShipAfterDate;
            cmd.CancelBackOrderDate   = state.CancelBackOrderDate;
            cmd.OverrideGlAccountId   = state.OverrideGlAccountId;
            cmd.Version               = ((IOrderItemMvoStateProperties)state).Version;
            cmd.Active                       = ((IOrderItemMvoStateProperties)state).Active;
            cmd.OrderOrderTypeId             = state.OrderOrderTypeId;
            cmd.OrderOrderName               = state.OrderOrderName;
            cmd.OrderExternalId              = state.OrderExternalId;
            cmd.OrderSalesChannelEnumId      = state.OrderSalesChannelEnumId;
            cmd.OrderOrderDate               = state.OrderOrderDate;
            cmd.OrderPriority                = state.OrderPriority;
            cmd.OrderEntryDate               = state.OrderEntryDate;
            cmd.OrderPickSheetPrintedDate    = state.OrderPickSheetPrintedDate;
            cmd.OrderStatusId                = state.OrderStatusId;
            cmd.OrderCurrencyUom             = state.OrderCurrencyUom;
            cmd.OrderSyncStatusId            = state.OrderSyncStatusId;
            cmd.OrderBillingAccountId        = state.OrderBillingAccountId;
            cmd.OrderOriginFacilityId        = state.OrderOriginFacilityId;
            cmd.OrderWebSiteId               = state.OrderWebSiteId;
            cmd.OrderProductStoreId          = state.OrderProductStoreId;
            cmd.OrderTerminalId              = state.OrderTerminalId;
            cmd.OrderTransactionId           = state.OrderTransactionId;
            cmd.OrderAutoOrderShoppingListId = state.OrderAutoOrderShoppingListId;
            cmd.OrderNeedsInventoryIssuance  = state.OrderNeedsInventoryIssuance;
            cmd.OrderIsRushOrder             = state.OrderIsRushOrder;
            cmd.OrderInternalCode            = state.OrderInternalCode;
            cmd.OrderRemainingSubTotal       = state.OrderRemainingSubTotal;
            cmd.OrderGrandTotal              = state.OrderGrandTotal;
            cmd.OrderInvoicePerShipment      = state.OrderInvoicePerShipment;
            cmd.OrderCreatedBy               = state.OrderCreatedBy;
            cmd.OrderCreatedAt               = state.OrderCreatedAt;
            cmd.OrderUpdatedBy               = state.OrderUpdatedBy;
            cmd.OrderUpdatedAt               = state.OrderUpdatedAt;
            cmd.OrderActive                  = state.OrderActive;

            if (state.ProductId == null)
            {
                cmd.IsPropertyProductIdRemoved = true;
            }
            if (state.ExternalProductId == null)
            {
                cmd.IsPropertyExternalProductIdRemoved = true;
            }
            if (state.Quantity == null)
            {
                cmd.IsPropertyQuantityRemoved = true;
            }
            if (state.CancelQuantity == null)
            {
                cmd.IsPropertyCancelQuantityRemoved = true;
            }
            if (state.SelectedAmount == null)
            {
                cmd.IsPropertySelectedAmountRemoved = true;
            }
            if (state.ExternalId == null)
            {
                cmd.IsPropertyExternalIdRemoved = true;
            }
            if (state.OrderItemTypeId == null)
            {
                cmd.IsPropertyOrderItemTypeIdRemoved = true;
            }
            if (state.OrderItemGroupSeqId == null)
            {
                cmd.IsPropertyOrderItemGroupSeqIdRemoved = true;
            }
            if (state.IsItemGroupPrimary == null)
            {
                cmd.IsPropertyIsItemGroupPrimaryRemoved = true;
            }
            if (state.FromInventoryItemId == null)
            {
                cmd.IsPropertyFromInventoryItemIdRemoved = true;
            }
            if (state.IsPromo == null)
            {
                cmd.IsPropertyIsPromoRemoved = true;
            }
            if (state.QuoteId == null)
            {
                cmd.IsPropertyQuoteIdRemoved = true;
            }
            if (state.QuoteItemSeqId == null)
            {
                cmd.IsPropertyQuoteItemSeqIdRemoved = true;
            }
            if (state.ShoppingListId == null)
            {
                cmd.IsPropertyShoppingListIdRemoved = true;
            }
            if (state.ShoppingListItemSeqId == null)
            {
                cmd.IsPropertyShoppingListItemSeqIdRemoved = true;
            }
            if (state.UnitPrice == null)
            {
                cmd.IsPropertyUnitPriceRemoved = true;
            }
            if (state.UnitListPrice == null)
            {
                cmd.IsPropertyUnitListPriceRemoved = true;
            }
            if (state.UnitAverageCost == null)
            {
                cmd.IsPropertyUnitAverageCostRemoved = true;
            }
            if (state.UnitRecurringPrice == null)
            {
                cmd.IsPropertyUnitRecurringPriceRemoved = true;
            }
            if (state.IsModifiedPrice == null)
            {
                cmd.IsPropertyIsModifiedPriceRemoved = true;
            }
            if (state.RecurringFreqUomId == null)
            {
                cmd.IsPropertyRecurringFreqUomIdRemoved = true;
            }
            if (state.ItemDescription == null)
            {
                cmd.IsPropertyItemDescriptionRemoved = true;
            }
            if (state.Comments == null)
            {
                cmd.IsPropertyCommentsRemoved = true;
            }
            if (state.CorrespondingPoId == null)
            {
                cmd.IsPropertyCorrespondingPoIdRemoved = true;
            }
            if (state.StatusId == null)
            {
                cmd.IsPropertyStatusIdRemoved = true;
            }
            if (state.SyncStatusId == null)
            {
                cmd.IsPropertySyncStatusIdRemoved = true;
            }
            if (state.EstimatedShipDate == null)
            {
                cmd.IsPropertyEstimatedShipDateRemoved = true;
            }
            if (state.EstimatedDeliveryDate == null)
            {
                cmd.IsPropertyEstimatedDeliveryDateRemoved = true;
            }
            if (state.AutoCancelDate == null)
            {
                cmd.IsPropertyAutoCancelDateRemoved = true;
            }
            if (state.DontCancelSetDate == null)
            {
                cmd.IsPropertyDontCancelSetDateRemoved = true;
            }
            if (state.DontCancelSetBy == null)
            {
                cmd.IsPropertyDontCancelSetByRemoved = true;
            }
            if (state.ShipBeforeDate == null)
            {
                cmd.IsPropertyShipBeforeDateRemoved = true;
            }
            if (state.ShipAfterDate == null)
            {
                cmd.IsPropertyShipAfterDateRemoved = true;
            }
            if (state.CancelBackOrderDate == null)
            {
                cmd.IsPropertyCancelBackOrderDateRemoved = true;
            }
            if (state.OverrideGlAccountId == null)
            {
                cmd.IsPropertyOverrideGlAccountIdRemoved = true;
            }
            if (state.OrderOrderTypeId == null)
            {
                cmd.IsPropertyOrderOrderTypeIdRemoved = true;
            }
            if (state.OrderOrderName == null)
            {
                cmd.IsPropertyOrderOrderNameRemoved = true;
            }
            if (state.OrderExternalId == null)
            {
                cmd.IsPropertyOrderExternalIdRemoved = true;
            }
            if (state.OrderSalesChannelEnumId == null)
            {
                cmd.IsPropertyOrderSalesChannelEnumIdRemoved = true;
            }
            if (state.OrderOrderDate == null)
            {
                cmd.IsPropertyOrderOrderDateRemoved = true;
            }
            if (state.OrderPriority == null)
            {
                cmd.IsPropertyOrderPriorityRemoved = true;
            }
            if (state.OrderEntryDate == null)
            {
                cmd.IsPropertyOrderEntryDateRemoved = true;
            }
            if (state.OrderPickSheetPrintedDate == null)
            {
                cmd.IsPropertyOrderPickSheetPrintedDateRemoved = true;
            }
            if (state.OrderStatusId == null)
            {
                cmd.IsPropertyOrderStatusIdRemoved = true;
            }
            if (state.OrderCurrencyUom == null)
            {
                cmd.IsPropertyOrderCurrencyUomRemoved = true;
            }
            if (state.OrderSyncStatusId == null)
            {
                cmd.IsPropertyOrderSyncStatusIdRemoved = true;
            }
            if (state.OrderBillingAccountId == null)
            {
                cmd.IsPropertyOrderBillingAccountIdRemoved = true;
            }
            if (state.OrderOriginFacilityId == null)
            {
                cmd.IsPropertyOrderOriginFacilityIdRemoved = true;
            }
            if (state.OrderWebSiteId == null)
            {
                cmd.IsPropertyOrderWebSiteIdRemoved = true;
            }
            if (state.OrderProductStoreId == null)
            {
                cmd.IsPropertyOrderProductStoreIdRemoved = true;
            }
            if (state.OrderTerminalId == null)
            {
                cmd.IsPropertyOrderTerminalIdRemoved = true;
            }
            if (state.OrderTransactionId == null)
            {
                cmd.IsPropertyOrderTransactionIdRemoved = true;
            }
            if (state.OrderAutoOrderShoppingListId == null)
            {
                cmd.IsPropertyOrderAutoOrderShoppingListIdRemoved = true;
            }
            if (state.OrderNeedsInventoryIssuance == null)
            {
                cmd.IsPropertyOrderNeedsInventoryIssuanceRemoved = true;
            }
            if (state.OrderIsRushOrder == null)
            {
                cmd.IsPropertyOrderIsRushOrderRemoved = true;
            }
            if (state.OrderInternalCode == null)
            {
                cmd.IsPropertyOrderInternalCodeRemoved = true;
            }
            if (state.OrderRemainingSubTotal == null)
            {
                cmd.IsPropertyOrderRemainingSubTotalRemoved = true;
            }
            if (state.OrderGrandTotal == null)
            {
                cmd.IsPropertyOrderGrandTotalRemoved = true;
            }
            if (state.OrderInvoicePerShipment == null)
            {
                cmd.IsPropertyOrderInvoicePerShipmentRemoved = true;
            }
            if (state.OrderCreatedBy == null)
            {
                cmd.IsPropertyOrderCreatedByRemoved = true;
            }
            if (state.OrderUpdatedBy == null)
            {
                cmd.IsPropertyOrderUpdatedByRemoved = true;
            }
            return(cmd);
        }
        public static IOrderItemMvoCommand ToCreateOrMergePatchOrderItemMvo <TCreateOrderItemMvo, TMergePatchOrderItemMvo>(this IOrderItemMvoState state)
            where TCreateOrderItemMvo : ICreateOrderItemMvo, new()
            where TMergePatchOrderItemMvo : IMergePatchOrderItemMvo, new()
        {
            bool bUnsaved = ((IOrderItemMvoState)state).IsUnsaved;

            if (bUnsaved)
            {
                return(state.ToCreateOrderItemMvo <TCreateOrderItemMvo>());
            }
            else
            {
                return(state.ToMergePatchOrderItemMvo <TMergePatchOrderItemMvo>());
            }
        }
Esempio n. 8
0
 public OrderItemMvoAggregate(IOrderItemMvoState state)
 {
     _state = state;
 }
Esempio n. 9
0
 public override IOrderItemMvoAggregate GetOrderItemMvoAggregate(IOrderItemMvoState state)
 {
     return(new OrderItemMvoAggregate(state));
 }
        protected bool IsRepeatedCommand(IOrderItemMvoCommand command, IEventStoreAggregateId eventStoreAggregateId, IOrderItemMvoState state)
        {
            bool repeated = false;

            if (((IOrderItemMvoStateProperties)state).OrderVersion > command.AggregateVersion)
            {
                var lastEvent = EventStore.GetEvent(typeof(IOrderItemMvoEvent), eventStoreAggregateId, command.AggregateVersion);
                if (lastEvent != null && lastEvent.CommandId == command.CommandId)
                {
                    repeated = true;
                }
            }
            return(repeated);
        }
 private void Persist(IEventStoreAggregateId eventStoreAggregateId, IOrderItemMvoAggregate aggregate, IOrderItemMvoState state)
 {
     EventStore.AppendEvents(eventStoreAggregateId, ((IOrderItemMvoStateProperties)state).OrderVersion, aggregate.Changes, () => { StateRepository.Save(state); });
     if (AggregateEventListener != null)
     {
         AggregateEventListener.EventAppended(new AggregateEvent <IOrderItemMvoAggregate, IOrderItemMvoState>(aggregate, state, aggregate.Changes));
     }
 }
 public abstract IOrderItemMvoAggregate GetOrderItemMvoAggregate(IOrderItemMvoState state);