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)); } } }
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); }
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; }
private static async Task CreateTimer(OrderPlaced @event, DurableOrchestrationContext context, CancellationToken timeoutCs) { if (@event.CooldownPeriodExpires > context.CurrentUtcDateTime) { await context.CreateLongRunningTimer(@event.CooldownPeriodExpires, timeoutCs); } }
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."); }
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(); } } }
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); }); }
/// <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)); }
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, } }); }
private void When(OrderPlaced @event) { Id = @event.OrderId; CustomerId = @event.CustomerId; Price = @event.Price; Status = OrderStatus.Pending; }
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)); }
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 _); } } }
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); }
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; } } }
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(); } }
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)); }
public void Handle(OrderPlaced m) { _dispatcher.Publish(new PriceOrder(m) { Order = m.Order }); }
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); }
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); }); }
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; } }
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); }
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; }