Example #1
0
        public void When(OrderPlaced @event)
        {
            switch (State)
            {
            case OrderProcessState.NotStarted:
                State           = OrderProcessState.OrderPlaced;
                Id              = @event.OrderId;
                Items           = @event.Items;
                RestaurantId    = @event.RestaurantId;
                UserId          = @event.UserId;
                DeliveryAddress = @event.DeliveryAddress;
                Amount          = @event.Amount;

                SendCommand(new ProcessPayment
                {
                    OrderId      = @event.OrderId,
                    RestaurantId = @event.RestaurantId,
                    Amount       = @event.Amount
                });

                break;

            // idempotence - same message sent twice
            case OrderProcessState.OrderPlaced:
                break;

            default:
                throw new InvalidOperationException("Invalid state for this message");
            }
        }
 public void ReceiveTick(string equityCode, decimal price)
 {
     using (this)
     {
         try
         {
             if (_validator.IsValid(equityCode, price))
             {
                 if (price < _config.EquityOrderThreshold)
                 {
                     _orderService.Buy(equityCode, _config.EquityOrderQuantity, price);
                     OrderPlaced?.Invoke(new OrderPlacedEventArgs(equityCode, price));
                 }
             }
             else
             {
                 OrderErrored?.Invoke(new OrderErroredEventArgs(equityCode, price,
                                                                new ArgumentException($"Equity code or price invalid; EquityCode: {equityCode}, Price: {price}")));
             }
         }
         catch (Exception exception)
         {
             OrderErrored?.Invoke(new OrderErroredEventArgs(equityCode, price, exception));
         }
     }
 }
Example #3
0
        public void after_orderPlaced_then_cookFood_and_set_timeout()
        {
            // given
            var d = new FakeDispatcher();
            var m = new Runner(d);
            var o = new Order {
                OrderId = Guid.NewGuid()
            };

            // when
            var inputEvent = new OrderPlaced {
                Order = o
            };

            m.Handle(inputEvent);

            // then
            Assert.Equal(2, d.Messages.Count);

            Assert.IsType <CookFood>(d.Messages[0]);
            Assert.IsType <Callback>(d.Messages[1]);

            var x0 = d.Messages[0] as CookFood;
            var x1 = d.Messages[1] as Callback;

            Assert.Equal(o.OrderId, x0.Order.OrderId);
            Assert.Equal(inputEvent.CorrelationId, x0.CorrelationId);
            Assert.Equal(inputEvent.MessageId, x0.ParentId);

            Assert.Equal(inputEvent.CorrelationId, x1.CorrelationId);
            Assert.Equal(inputEvent.MessageId, x1.ParentId);
            Assert.Equal(5, x1.Seconds);
            Assert.IsType <CookFoodCalledBack>(x1.Payload);
        }
        public void Setup()
        {
            this._dbName = this.GetType().Name + "-" + Guid.NewGuid();
            using (var context = new ConferenceRegistrationDbContext(this._dbName)) {
                if (context.Database.Exists())
                {
                    context.Database.Delete();
                }

                context.Database.Create();
            }

            var blobStorage = new MemoryBlobStorage();

            this._sut = new DraftOrderViewModelGenerator(() => new ConferenceRegistrationDbContext(_dbName));
            this._dao = new OrderDao(() => new ConferenceRegistrationDbContext(_dbName), blobStorage,
                                     new JsonTextSerializer());

            System.Diagnostics.Trace.Listeners.Clear();

            this._orderPlacedEvent = new OrderPlaced {
                SourceId     = Guid.NewGuid(),
                ConferenceId = Guid.NewGuid(),
                AccessCode   = "asdf",
                Seats        = new[] { new SeatQuantity(Guid.NewGuid(), 5) },
                Version      = 1
            };

            _sut.Handle(_orderPlacedEvent);
        }
Example #5
0
        public void PlaceOrder(Guid UserID, CartVariantItemsDTO cartVariantItemsDTO, Guid addressID)
        {
            Guid     orderID       = Guid.NewGuid();
            Guid     orderPlacedID = Guid.NewGuid();
            DateTime dateTime      = DateTime.Now;
            Order    order         = new Order {
                ID = orderID, DeliveryAddressID = addressID, TotalAmount = cartVariantItemsDTO.SubTotal, isCancelled = "N", OrderDate = dateTime, DeliveryDate = dateTime, StatusID = 1
            };

            shoppingCartEntities.Orders.Add(order);
            shoppingCartEntities.SaveChanges();
            OrderPlaced orderPlaced = new OrderPlaced {
                ID = orderPlacedID, OrderID = orderID, UserID = UserID
            };

            shoppingCartEntities.OrderPlaceds.Add(orderPlaced);
            shoppingCartEntities.SaveChanges();

            foreach (var cartItem in cartVariantItemsDTO.CartItems)
            {
                OrderPlacedVariant orderPlacedVariant = new OrderPlacedVariant
                {
                    ID            = Guid.NewGuid(),
                    OrderPlacedID = orderPlacedID,
                    VariantID     = cartItem.Variant.ID,
                    SellingPrice  = cartItem.Variant.DiscountedPrice,
                    Quantity      = cartItem.Quantity
                };

                shoppingCartEntities.OrderPlacedVariants.Add(orderPlacedVariant);
                shoppingCartEntities.SaveChanges();
            }
            return;
        }
Example #6
0
 private static async Task CreateTimer(OrderPlaced @event, DurableOrchestrationContext context, CancellationToken timeoutCs)
 {
     if (@event.CooldownPeriodExpires > context.CurrentUtcDateTime)
     {
         await context.CreateLongRunningTimer(@event.CooldownPeriodExpires, timeoutCs);
     }
 }
Example #7
0
        public async Task Handle(OrderPlaced message, IMessageHandlerContext context)
        {
            Console.WriteLine($"Received OrderPlaced event for order {message.OrderId} from customer {message.CustomerId}, total amount {message.OrderTotalAmount}$.");
            Console.WriteLine($"Customer {Data.CustomerId} MonthlyRunningTotal is {Data.MonthlyRunningTotal}$.");

            var discount = Data.MonthlyRunningTotal > 300 ? 10 : 0;

            Console.WriteLine($"Calculated discount for order {message.OrderId} is {discount}%.");

            Data.MonthlyRunningTotal += message.OrderTotalAmount;
            await context.SendLocal(new ProcessOrder()
            {
                OrderId  = message.OrderId,
                Discount = discount
            });

            Console.WriteLine($"ProcessOrder for order {message.OrderId} command sent.");

            var delay = DateTime.Now.AddMinutes(1);

            await RequestTimeout(context, delay, new DeductFromRunningTotal()
            {
                OrderTotalAmount = message.OrderTotalAmount
            });

            Console.WriteLine($"Timeout for order {message.OrderId} requested.");
        }
Example #8
0
        private static async Task WaitForEventOrTimeout(
            DurableOrchestrationContext context,
            IAggregateRepository repository,
            ILogger log,
            OrderPlaced @event)
        {
            using (var timeoutCs = new CancellationTokenSource())
            {
                var waitForCancel  = context.WaitForExternalEvent(InternalEvents.OrderCancelled);
                var waitForTimeout = context.CreateTimer(@event.CooldownPeriodExpires, timeoutCs.Token);
                log.LogInformation("Waiting for either a cooldown to expire OR the customer to cancel");
                Task winner = await Task.WhenAny(waitForCancel, waitForTimeout);

                if (winner == waitForCancel)
                {
                    await CancelOrder(repository, log, @event);
                }
                else if (winner == waitForTimeout)
                {
                    await ProvisionOrder(repository, log, @event);
                }

                if (!waitForTimeout.IsCompleted)
                {
                    // All pending timers must be complete or cancelled before the function exits
                    timeoutCs.Cancel();
                }
            }
        }
Example #9
0
 private void When(OrderPlaced @event)
 {
     this.Id         = @event.OrderId;
     this.CustomerId = @event.CustomerId;
     this.Price      = @event.Price;
     this.Status     = OrderStatus.Pending;
 }
 public async Task Handle(OrderPlaced message, IMessageHandlerContext context)
 {
     await context.Send(new BillOrder
     {
         OrderId = message.OrderId
     });
 }
        public async Task Then_The_Handler_Is_Resolved_From_The_Custom_Resolver()
        {
            // Arrange
            var future = new Future <OrderPlaced>();

            var services = GivenJustSaying()
                           .ConfigureJustSaying((builder) => builder.WithLoopbackQueue <OrderPlaced>(UniqueName + "-dispatched"))
                           .ConfigureJustSaying((builder) => builder.Services((config) => config.WithHandlerResolver(new MyCustomHandlerResolver(future))));

            await WhenAsync(
                services,
                async (publisher, listener, cancellationToken) =>
            {
                listener.Start(cancellationToken);

                var message = new OrderPlaced(Guid.NewGuid().ToString());

                // Act
                await publisher.PublishAsync(message, cancellationToken);

                //Assert
                await future.DoneSignal;
                future.ReceivedMessageCount.ShouldBeGreaterThan(0);
            });
        }
Example #12
0
        /// <inheritdoc/>
        public void ReceiveTick(string equityCode, decimal price)
        {
            if (IsInhibited())
            {
                return;
            }

            try
            {
                if (price < _thresholdLevel)
                {
                    lock (_syncLock)
                    {
                        if (IsInhibited())
                        {
                            return;
                        }
                        _orderService.Buy(equityCode, 1, price);
                        _loggerService.Info($"Bought equityCode '{equityCode}' at price '{price}'");
                        InhibitFurtherTicks();
                    }
                    OrderPlaced?.Invoke(new OrderPlacedEventArgs(equityCode, price));
                }
            }
            catch (Exception ex)
            {
                _loggerService.Error($"Error seen in ReceiveTick: {ex.Message}", ex);
                InhibitFurtherTicks();
                OrderErrored?.Invoke(new OrderErroredEventArgs(equityCode, price, ex));
            }
        }
        public Task Handle(PlaceOrder message, IMessageHandlerContext context)
        {
            SqlConnection conn = new SqlConnection(ConfigurationManager.ConnectionStrings["conn"].ConnectionString);

            log.Info($"Received PlaceOrder, OrderId = {message.OrderId}, Date = {message.FechaIngreso}, Name = {message.Description}, ");

            var orderPlaced = new OrderPlaced
            {
                OrderId      = message.OrderId,
                FechaIngreso = DateTime.Now,
                Amount       = message.Amount,
                CustomerID   = message.CustomerID,
                CustomerName = message.CustomerName,
                Description  = message.Description
            };

            conn.Open();
            SqlCommand com = new SqlCommand("guardarOrden", conn);

            com.CommandType = System.Data.CommandType.StoredProcedure;
            com.Parameters.AddWithValue("@OrderID", message.OrderId);
            com.Parameters.AddWithValue("@OrderDescription", message.Description);
            com.Parameters.AddWithValue("@CustomerID", message.CustomerID);
            com.Parameters.AddWithValue("@CustomerName", message.CustomerName);
            com.Parameters.AddWithValue("@OrderAmount", message.Amount);

            com.ExecuteNonQuery();
            return(context.Publish(orderPlaced));
        }
Example #14
0
        public void Handle(OrderPlaced message)
        {
            if (message == null)
            {
                return;
            }

            _publisher.Publish(new CookFood()
            {
                CorrelationId = message.CorrelationId,
                CausationId   = message.EventId,
                Order         = message.Order
            });

            _publisher.Publish(new SendToMeInX(10)
            {
                CorrelationId = message.CorrelationId,
                CausationId   = message.EventId,
                Order         = message.Order,
                Message       = new CookFoodTimedout()
                {
                    CorrelationId = message.CorrelationId,
                    CausationId   = message.EventId,
                    Order         = message.Order,
                }
            });
        }
Example #15
0
 private void When(OrderPlaced @event)
 {
     Id         = @event.OrderId;
     CustomerId = @event.CustomerId;
     Price      = @event.Price;
     Status     = OrderStatus.Pending;
 }
Example #16
0
        public async Task <IActionResult> PlaceOrder(string orderId, [FromBody] PlaceOrder orderCommand)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var order = await _dbContext.Orders.FirstOrDefaultAsync(o => o.OrderId == orderId);

            if (order == null)
            {
                return(NotFound());
            }

            order.AfterPayment = orderCommand.AfterPayment;

            if (order.AfterPayment)
            {
                order.AddStateChange(OrderState.AWAITINGAFTERPAYMENT);
            }
            else
            {
                order.AddStateChange(OrderState.PAYMENTINPROGRESS);
            }

            await _dbContext.SaveChangesAsync();

            OrderPlaced e = Mapper.Map <OrderPlaced>(order);
            await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");

            return(AcceptedAtRoute("GetByOrderId", new { orderId = order.OrderId }, order));
        }
Example #17
0
        public Task Handle(PlaceOrder message, IMessageHandlerContext context)
        {
            logger.Info($"Received PlaceOrder, OrderId = {message.OrderId}");

            LogTrace(message);

            // This is normally where some business logic would occur

            // 25% of messages always fail with a missing parameter error - persistent
            // all messages fail 10% of the time with a deadlock - transient
            // all messages fail 10% of the time with a FraudDetectionUnavailableException - transient
            var d = message.GetHashCode();

            if (d > (int.MaxValue / 4) * 3)
            {
                throw SqlExceptionCreator.NewSqlException(137); // Must declare the scalar variable - PERSISTENT
            }
            else if (new Random(Guid.NewGuid().GetHashCode()).NextDouble() > 0.90)
            {
                throw SqlExceptionCreator.NewSqlException(1205); // deadlock - TRANSIENT
            }
            else if (new Random(Guid.NewGuid().GetHashCode()).NextDouble() > 0.80)
            {
                throw new FraudDetectionUnavailableException("Fraud detection system is down for a short time"); // SEMI TRANSIENT
            }

            var orderPlaced = new OrderPlaced
            {
                OrderId = message.OrderId
            };

            return(context.Publish(orderPlaced));
        }
        public async Task <IActionResult> PlaceOrder()
        {
            var orderId = Guid.NewGuid().ToString().Substring(0, 8);

            var payloadLocation = await _storageRepository
                                  .SaveMessageToStorage("very big message from storage");

            //Create the order then publish that the order was placed
            var orderPlaced = new OrderPlaced
            {
                OrderId         = orderId,
                PayloadLocation = payloadLocation
            };

            _log.Info($"Publishing OrderPlaced, OrderId = {orderId}");

            await _messageSession.Publish(orderPlaced)
            .ConfigureAwait(false);

            dynamic model = new ExpandoObject();

            model.OrderId = orderId;

            return(View(model));
        }
        public void ReceiveTick(string equityCode, decimal price)
        {
            var lockObject = LockObjects.GetOrAdd(equityCode, new object());

            lock (lockObject)
            {
                if (_ignoreFurtherTicks || price >= _orderParameters.PriceThreshold)
                {
                    return;
                }

                _ignoreFurtherTicks = true;

                try
                {
                    _orderService.Buy(equityCode, _orderParameters.Quantity, price);

                    OrderPlaced?.Invoke(new OrderPlacedEventArgs(equityCode, price));
                }
                catch (Exception ex)
                {
                    OrderErrored?.Invoke(new OrderErroredEventArgs(equityCode, price, ex));
                    _ignoreFurtherTicks = true;
                }
                finally
                {
                    LockObjects.TryRemove(equityCode, out _);
                }
            }
        }
Example #20
0
        public Task Handle(PlaceOrder message, IMessageHandlerContext context)
        {
            _processingCount++;

            _log.Info($"RECV {nameof(PlaceOrder)} [{_processingCount}], {nameof(message.Id)}: {message.Id}");

            var orderPlaced = new OrderPlaced {
                OrderId = message.Id, IsGrouped = message.IsGrouped
            };
            var task = context.Publish(orderPlaced);

            _log.Info($"POST {nameof(OrderPlaced)} [{_processingCount}], {nameof(orderPlaced.OrderId)}: {orderPlaced.OrderId}");

            if (message.IsGrouped != _groupItems)
            {
                // Grouping completed.
                if (_groupItems)
                {
                    _groupItems = false;
                    _log.Info(_sw.LogTimeToMessage("GROUP COMPLETE "));
                }
                // Grouping started;
                else
                {
                    _groupItems = true;
                    _sw         = StopwatchExtensions.CreateStartSW();
                }
            }

            return(task);
        }
Example #21
0
        public void ReceiveTick(string equityCode, decimal price)
        {
            if (Completed || price >= this.Price)
            {
                return;
            }
            lock (this._lock)
            {
                if (Completed)
                {
                    return;
                }

                try
                {
                    this._orderService.Buy(this.EquityCode, this.Quantity, price);
                    OrderPlaced?.Invoke(new OrderPlacedEventArgs(this.EquityCode, price));
                }
                catch (Exception ex)
                {
                    OrderErrored?.Invoke(new OrderErroredEventArgs(this.EquityCode, price, ex));
                }
                finally
                {
                    this.Completed = true;
                }
            }
        }
Example #22
0
        public void Handle(OrderPlaced message)
        {
            Data.OrderId  = message.OrderId;
            Data.IsPlaced = true;

            CheckAndPublish();
        }
        static async Task Start(IEndpointInstance endpointInstance)
        {
            Console.WriteLine("Press '1' to publish the OrderReceived event");
            Console.WriteLine("Press any other key to exit");

            #region PublishLoop

            while (true)
            {
                var key = Console.ReadKey();
                Console.WriteLine();

                var orderReceivedId = Guid.NewGuid();
                if (key.Key == ConsoleKey.D1)
                {
                    var orderReceived = new OrderPlaced
                    {
                        OrderId = orderReceivedId
                    };
                    await endpointInstance.Publish(orderReceived)
                    .ConfigureAwait(false);

                    Console.WriteLine($"Published OrderReceived Event with Id {orderReceivedId}.");
                }
                else
                {
                    return;
                }
            }

            #endregion
        }
        public void PlaceOrder(Guid userID, Guid addressID, Shared.DTO.Cart.CartItemsDTO cartItemsDTO)
        {
            Guid  OrderId       = Guid.NewGuid();
            Guid  OrderPlacedId = Guid.NewGuid();
            Order order         = new Order {
                ID        = OrderId, DeliveryAddressID = addressID, TotalAmount = cartItemsDTO.TotalAmount, isCancelled = "N",
                OrderDate = DateTime.Now, DeliveryDate = DateTime.Now, StatusID = 1
            };

            FutureKartContext.Orders.Add(order);
            FutureKartContext.SaveChanges();
            OrderPlaced orderPlaced = new OrderPlaced {
                ID = OrderPlacedId, OrderID = OrderId, UserID = userID
            };

            FutureKartContext.OrderPlaceds.Add(orderPlaced);
            FutureKartContext.SaveChanges();
            foreach (var cartItem in cartItemsDTO.CartItems)
            {
                OrderPlacedVariant orderPlacedVariant = new OrderPlacedVariant {
                    ID = Guid.NewGuid(), OrderPlacedID = OrderPlacedId, VariantID = cartItem.Variant.ID, SellingPrice = cartItem.Variant.DiscountedPrice, Quantity = cartItem.Quantity
                };
                FutureKartContext.OrderPlacedVariants.Add(orderPlacedVariant);
                FutureKartContext.SaveChanges();
            }
        }
Example #25
0
        public Task Handle(PlaceOrder message, IMessageHandlerContext context)
        {
            log.Info($"Received PlaceOrder, OrderId = {message.OrderId}");

            // This is normally where some business logic would occur

            #region ThrowTransientException

            // Uncomment to test throwing transient exceptions
            //if (random.Next(0, 5) == 0)
            //{
            //    throw new Exception("Oops");
            //}

            #endregion

            #region ThrowFatalException

            // Uncomment to test throwing fatal exceptions
            //throw new Exception("BOOM");

            #endregion

            var orderPlaced = new OrderPlaced
            {
                OrderId = message.OrderId
            };

            log.Info($"Publishing OrderPlaced, OrderId = {message.OrderId}");

            return(context.Publish(orderPlaced));
        }
Example #26
0
 public void Handle(OrderPlaced m)
 {
     _dispatcher.Publish(new PriceOrder(m)
     {
         Order = m.Order
     });
 }
Example #27
0
        public Task Handle(OrderPlaced message, IMessageHandlerContext context)
        {
            Log.Info($"Start place order process for order id {message.OrderId}");

            Data.OrderId = message.OrderId;
            return(Task.CompletedTask);
        }
Example #28
0
        public async Task Then_The_Handler_Is_Resolved()
        {
            // Arrange
            var future = new Future <OrderPlaced>();

            var services = GivenJustSaying()
                           .ConfigureJustSaying((builder) => builder.WithLoopbackQueue <OrderPlaced>(UniqueName))
                           .AddTransient <IHandlerAsync <OrderPlaced>, OrderProcessor>()
                           .AddSingleton(future);

            await WhenAsync(
                services,
                async (publisher, listener, cancellationToken) =>
            {
                _ = listener.StartAsync(cancellationToken);

                var message = new OrderPlaced(Guid.NewGuid().ToString());

                // Act
                await publisher.PublishAsync(message, cancellationToken);

                //Assert
                await future.DoneSignal;
                future.ReceivedMessageCount.ShouldBeGreaterThan(0);
            });
        }
Example #29
0
 private void Apply(OrderPlaced e)
 {
     Id          = e.Id;
     ProductId   = e.ProductId;
     Quantity    = e.Quantity;
     HasBeenPaid = false;
 }
        public Task Handle(OrderPlaced message, IMessageHandlerContext context)
        {
            Log.Info($"OrderPlaced message received.");

            Data.IsOrderPlaced = true;

            return(ProcessOrder(context));
        }
 public void InsertOrUpdate(OrderPlaced orderplaced)
 {
     if (orderplaced.Id == default(System.Guid)) {
         // New entity
         orderplaced.Id = Guid.NewGuid();
         context.OrderPlaceds.Add(orderplaced);
     } else {
         // Existing entity
         context.Entry(orderplaced).State = EntityState.Modified;
     }
 }
Example #32
0
        public void WhenMidgetNotifiedOfOrderPlaced_ThenMidgetSendsCommandToCookFood()
        {
           
            var orderPlaced = new OrderPlaced(order, Guid.NewGuid(), orderGuid);

            var midget = new EnglishMidget(bus, orderGuid);
            midget.Handle(orderPlaced);

            //var cookFood = (CookFood) bus.Messages.Single();
            Assert.That(bus.Messages.Single(), Is.InstanceOf<CookFood>());
        }
 public ActionResult Create(OrderPlaced orderplaced)
 {
     if (ModelState.IsValid) {
         orderplacedRepository.InsertOrUpdate(orderplaced);
         orderplacedRepository.Save();
         return RedirectToAction("Index");
     } else {
         ViewBag.PossibleWaiters = waiterRepository.All;
         ViewBag.PossibleRestaurants = restaurantRepository.All;
         return View();
     }
 }
        public given_a_placed_order()
        {
            this.orderPlacedEvent = new OrderPlaced
            {
                SourceId = Guid.NewGuid(),
                ConferenceId = Guid.NewGuid(),
                AccessCode = "asdf",
                Seats = new[] { new SeatQuantity(Guid.NewGuid(), 5) },
                Version = 1
            };

            sut.Handle(orderPlacedEvent);
        }
        public given_a_placed_order()
        {
            System.Diagnostics.Trace.Listeners.Clear();

            this.orderPlacedEvent = new OrderPlaced
            {
                SourceId = Guid.NewGuid(),
                ConferenceId = Guid.NewGuid(),
                AccessCode = "asdf",
                Seats = new[] { new SeatQuantity(Guid.NewGuid(), 5) },
                Version = 1
            };

            sut.Handle(orderPlacedEvent);
        }
Example #36
0
        public PageModel Setup(MediaModel mediaModel)
        {
            var pageModel = new PageModel();

            var productSearch = new ProductSearch
            {
                Name = "Categories",
                UrlSegment = "categories",
                RevealInNavigation = true
            };
            var categoryContainer = new ProductContainer
            {
                Name = "Products",
                UrlSegment = "products",
                RevealInNavigation = false
            };
            _documentService.AddDocument(productSearch);
            _documentService.PublishNow(productSearch);
            _documentService.AddDocument(categoryContainer);
            _documentService.PublishNow(categoryContainer);
            pageModel.ProductSearch = productSearch;

            var now = DateTime.UtcNow;
            var yourBasket = new Cart
            {
                Name = "Your Basket",
                UrlSegment = "basket",
                RevealInNavigation = false,
                PublishOn = now
            };
            _documentService.AddDocument(yourBasket);
            var enterOrderEmail = new EnterOrderEmail
            {
                Name = "Enter Order Email",
                UrlSegment = "enter-order-email",
                RevealInNavigation = false,
                Parent = yourBasket,
                DisplayOrder = 0,
                PublishOn = now,
            };
            _documentService.AddDocument(enterOrderEmail);
            var setPaymentDetails = new PaymentDetails
            {
                Name = "Set Payment Details",
                UrlSegment = "set-payment-details",
                RevealInNavigation = false,
                Parent = yourBasket,
                DisplayOrder = 1,
                PublishOn = now,
            };
            _documentService.AddDocument(setPaymentDetails);
            var setDeliveryDetails = new SetShippingDetails
            {
                Name = "Set Shipping Details",
                UrlSegment = "set-shipping-details",
                RevealInNavigation = false,
                Parent = yourBasket,
                DisplayOrder = 2,
                PublishOn = now,
            };
            _documentService.AddDocument(setDeliveryDetails);
            var orderPlaced = new OrderPlaced
            {
                Name = "Order Placed",
                UrlSegment = "order-placed",
                RevealInNavigation = false,
                Parent = yourBasket,
                DisplayOrder = 3,
                PublishOn = now,
            };
            _documentService.AddDocument(orderPlaced);

            // User Account
            var userAccount = new SitemapPlaceholder
            {
                Name = "User Account",
                UrlSegment = "user-account",
                RevealInNavigation = false,
                PublishOn = now
            };
            _documentService.AddDocument(userAccount);

            var userAccountInfo = new UserAccountInfo
            {
                Name = "Account Details",
                UrlSegment = "user-account-details",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccount
            };
            _documentService.AddDocument(userAccountInfo);

            var userAccountPassword = new UserAccountChangePassword
            {
                Name = "Change Password",
                UrlSegment = "user-account-change-password",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccount
            };
            _documentService.AddDocument(userAccountPassword);

            var userAccountAddresses = new UserAccountAddresses
            {
                Name = "Account Addresses",
                UrlSegment = "user-account-addresses",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccount
            };
            _documentService.AddDocument(userAccountAddresses);

            var editAddress = new UserAccountEditAddress
            {
                Name = "Edit Address",
                UrlSegment = userAccountAddresses.UrlSegment + "/edit-address",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccountAddresses
            };
            _documentService.AddDocument(editAddress);

            var userAccountOrders = new UserAccountOrders
            {
                Name = "Orders",
                UrlSegment = "user-account-orders",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccount
            };
            _documentService.AddDocument(userAccountOrders);

            var userOrder = new UserOrder
            {
                Name = "View Order",
                UrlSegment = "user-account-orders/order",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccountOrders
            };
            _documentService.AddDocument(userOrder);

            var userAccountReviews = new UserAccountReviews
            {
                Name = "Reviews",
                UrlSegment = "user-account-reviews",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccount
            };
            _documentService.AddDocument(userAccountReviews);

            var userAccountRewards = new UserAccountRewardPoints
            {
                Name = "Reward Points",
                UrlSegment = "user-account-reward-points",
                RevealInNavigation = false,
                PublishOn = now,
                Parent = userAccount
            };
            _documentService.AddDocument(userAccountRewards);

            // End User Account


            //Added to cart
            var addedToCart = new ProductAddedToCart
            {
                Name = "Added to Basket",
                UrlSegment = "add-to-basket",
                RevealInNavigation = false,
                PublishOn = now
            };
            _documentService.AddDocument(addedToCart);
            pageModel.ProductAddedToCart = addedToCart;

            var wishlist = new ShowWishlist
            {
                Name = "Wishlist",
                UrlSegment = "wishlist",
                RevealInNavigation = true,
                PublishOn = now
            };
            _documentService.AddDocument(wishlist);

            var newIn = new NewInProducts
            {
                Name = "New In",
                UrlSegment = "new-in",
                RevealInNavigation = true,
                PublishOn = now
            };
            _documentService.AddDocument(newIn);

            var about = new TextPage()
            {
                Name = "About us",
                UrlSegment = "about-us",
                RevealInNavigation = true,
                PublishOn = now,
                BodyContent = EcommerceInstallInfo.AboutUsText
            };
            _documentService.AddDocument(about);

            //update core pages
            var homePage = _documentService.GetDocumentByUrl<TextPage>("home");
            if (homePage != null)
            {
                homePage.BodyContent = EcommerceInstallInfo.HomeCopy;
                var templates = _pageTemplateAdminService.Search(new PageTemplateSearchQuery());
                var homeTemplate = templates.FirstOrDefault(x => x.Name == "Home Page");
                if (homeTemplate != null)
                {
                    homePage.PageTemplate = homeTemplate;
                }

                homePage.SubmitButtonText = "Sign up";
                _documentService.SaveDocument(homePage);
                pageModel.HomePage = homePage;
            }
            var page2 = _documentService.GetDocumentByUrl<TextPage>("page-2");
            if (page2 != null)//demopage in core not needed
                _documentService.DeleteDocument(page2);

            var contactus = _documentService.GetDocumentByUrl<TextPage>("contact-us");
            if (contactus != null)//demopage in core not needed
                _documentService.DeleteDocument(contactus);

            //Added to cart
            var contactUs = new ContactUs()
            {
                Name = "Contact Us",
                UrlSegment = "contact-us",
                RevealInNavigation = true,
                PublishOn = now,
                Latitude = 55.01021m,
                Longitude = -1.44998m,
                Address = EcommerceInstallInfo.Address,
                PinImage = mediaModel.Logo.FileUrl,
                BodyContent = "[form]",
                FormDesign = EcommerceInstallInfo.ContactFormDesign
            };
            _documentService.AddDocument(contactUs);
            GetFormProperties(contactUs);

            var brandListing = new BrandListing
            {
                Name = "Brands",
                UrlSegment = "brands",
                RevealInNavigation = true,
                PublishOn = now,
                BodyContent = ""
            };
            _documentService.AddDocument(brandListing);

            return pageModel;
        }