public static OrderRepresentation Map(Order order, ResourceLinker resourceLinker, NancyContext context)
 {
     return new OrderRepresentation(order)
       {
     Links = GetLinks(order, resourceLinker, context).ToList()
       };
 }
Example #2
0
 public void IfItemHasQuantity0_ThenReturnInvalidMessage()
 {
     var order = new Order() ;
     order.AddItem(new OrderItem { Quantity = 0 });
     order.GetErrorMessages()
         .Should().Contain("Item 0: Quantity should be greater than 0.");
 }
 public static OrderRepresentation Map(Order order, string baseAddress)
 {
     return new OrderRepresentation(order)
      {
        Links = GetLinks(order, baseAddress).ToList()
      };
 }
        public void create_extended_db()
        {
            var factory = Fluently.Configure()
            .Database(MsSqlConfiguration
                         .MsSql2008
                         .ShowSql()
                         .ConnectionString(a_builder => a_builder.FromConnectionStringWithKey("DefaultExtendedConnection"))
                         )
                                 .ExposeConfiguration(a_configuration =>
                                    new SchemaExport(a_configuration).Create(true, true))
            .Mappings(a_configuration => a_configuration
                                            .FluentMappings
                                            .AddFromAssemblyOf<OrderMapping>()
                                            .AddFromAssemblyOf<OrderItemExtendedMapping>())
            .BuildSessionFactory();

             var session = factory.OpenSession();
             Order order = new Order();
             order.AddOrderItem(new OrderItemExtended
             {
            DateOfPurchase = DateTime.Now,
            Quantity = 10
             });

             session.Save(order);
             session.Flush();

             // Pobranie
             var recived = session.Get<Order>(order.Id);
        }
Example #5
0
        /// <summary>
        /// Creates an order
        /// </summary>
        /// <param name="a_orderModel">Order dto model</param>
        /// <remarks>
        /// Json Invoke: {Location: "inShop", Items: {Name: "latte", Quantity: 5}}
        /// Xml invoke: 
        /// </remarks>
        /// <returns>Response</returns>
        public HttpResponseMessage Post(OrderDto a_orderModel)
        {
            var order = new Order
             {
            Date = DateTime.Today,
            Location = a_orderModel.Location
             };

             foreach (var requestedItem in a_orderModel.Items)
             {
            var product = m_productRepository.GetByName(requestedItem.Name);
            if (product == null)
            {
               return Request.CreateResponse(HttpStatusCode.BadRequest, string.Format("We don't offer {0}", requestedItem.Name));
            }

            var orderItem = new OrderItem(product,
                                        requestedItem.Quantity,
                                        product.Price,
                                        requestedItem.Preferences.ToDictionary(a_x => a_x.Key, a_y => a_y.Value));
            order.AddItem(orderItem);
             }

             if (!order.IsValid())
             {
            var content = string.Join("\n", order.GetErrorMessages());
            return Request.CreateResponse(HttpStatusCode.BadRequest, string.Format("Invalid entities values {0}", content));
             }

             m_orderRepository.MakePersistent(order);
             //var uri = resourceLinker.GetUri<OrderResourceHandler>(orderResource => orderResource.Get(0, null), new { orderId = order.Id });
             return Request.CreateResponse(HttpStatusCode.OK);
        }
 public OrderRepresentation(Order order)
 {
     Location = order.Location;
       Cost = order.Total;
       Items = order.Items.Select(item => new OrderItemRepresentation(item)).ToList();
       Status = order.Status;
 }
Example #7
0
 public void UpdateOrder(Order order)
 {
     var foundIndex = _orders.FindIndex(o => o.Id == order.Id);
     if (foundIndex >= 0)
     {
         _orders[foundIndex] = order;
     }
 }
 public void order_add_test_shoud_add()
 {
     Order order = new Order();
      order.AddOrderItem(new OrderItemExtended
     {
        DateOfPurchase = DateTime.Now,
        Quantity = 10
     });
 }
        private static IEnumerable<Link> GetLinks(Order order, string baseAddress)
        {
            var baseUri = new UriSegment(baseAddress);
              var linker = new ResourceLinker(baseAddress);

              var get = new Link(linker.BuildUriString(OrderResourceHandler.Path,
                                               OrderResourceHandler.SlashOrderId,
                                               new {orderId = order.Id}),
                         baseUri + "docs/order-get.htm",
                         MediaTypes.Default);

              var update = new Link(linker.BuildUriString(OrderResourceHandler.Path,
                                                  OrderResourceHandler.SlashOrderId,
                                                  new {orderId = order.Id}),
                            baseUri + "docs/order-update.htm",
                            MediaTypes.Default);

              var cancel = new Link(linker.BuildUriString(OrderResourceHandler.Path,
                                                  OrderResourceHandler.SlashOrderId,
                                                  new {orderId = order.Id}),
                            baseUri + "docs/order-cancel.htm",
                            MediaTypes.Default);

              var pay = new Link(linker.BuildUriString(OrderResourceHandler.Path,
                                               OrderResourceHandler.PaymentPath,
                                               new {orderId = order.Id}),
                         baseUri + "docs/order-pay.htm",
                         MediaTypes.Default);

              var receipt = new Link(linker.BuildUriString(OrderResourceHandler.Path,
                                                   OrderResourceHandler.ReceiptPath,
                                                   new {orderId = order.Id}),
                             baseUri + "docs/receipt-coffee.htm",
                             MediaTypes.Default);

              switch (order.Status)
              {
            case OrderStatus.Unpaid:
              yield return get;
              yield return update;
              yield return cancel;
              yield return pay;
              break;
            case OrderStatus.Paid:
            case OrderStatus.Delivered:
              yield return get;
              break;
            case OrderStatus.Ready:
              yield return receipt;
              break;
            case OrderStatus.Canceled:
              yield break;
            default:
              yield break;
              }
        }
 public static OrderRepresentation Map(Order order, string baseAddress)
 {
     return new OrderRepresentation
      {
        Cost = order.Total,
        Status = order.Status,
        Location = order.Location,
        Items = order.Items.Select(i => new OrderItemRepresentation
                                        {
                                          Name = i.Product.Name,
                                          Preferences = i.Preferences.ToDictionary(p => p.Key, p => p.Value),
                                          Quantity = i.Quantity
                                        }).ToList(),
        Links = GetLinks(order, baseAddress).ToList()
      };
 }
Example #11
0
        public void IfTheProductDoesNotAllowCustomization_ThenReturnInvalidMessage()
        {
            var product = new Product
                              {
                                  Name = "latte",
                                  Customizations = {new Customization{Name = "size", PossibleValues = {"medium","large"}}}
                              };

            var order = new Order();
            order.AddItem(new OrderItem
                            {
                                Quantity = 1,
                                Product = product,
                                Preferences = { { "milk", "lot" } }
                            });
            order.GetErrorMessages()
                .Should().Contain("Item 0: The product latte does not have a customization: milk/lot.");
        }
Example #12
0
        public static DAL.App.DTO.DomainLikeDTO.Order MapFromDomain(Domain.Order order)
        {
            var res = order == null ? null : new DAL.App.DTO.DomainLikeDTO.Order
            {
                Id                = order.Id,
                Description       = order.Description.Translate(),
                OrderCreationTime = order.OrderCreationTime,
                ShipperId         = order.ShipperId,
                Shipper           = ShipperMapper.MapFromDomain(order.Shipper),
                ShopId            = order.ShopId,
                Shop              = ShopMapper.MapFromDomain(order.Shop)
            };

            if (order?.ProductsInOrder != null)
            {
                res.ProductsInOrder = order.ProductsInOrder.Select(e => ProductInOrderMapper.MapFromDomain(e)).ToList();
            }

            return(res);
        }
Example #13
0
        public void CanStoreAnOrderWithPayment()
        {
            long id;
            using (var session = m_sessionFactory.OpenSession())
            using (var tx = session.BeginTransaction())
            {
                var productRepository = new Repository<Product>(session);
                var product = new Product { Name = "Latte", Price = 10.4m };
                productRepository.MakePersistent(product);

                var orderRepository = new Repository<Order>(session);
                var order = new Order
                {
                    Date = new DateTime(2011, 1, 1),
                    Location = Location.InShop,
                };
                order.AddItem(new OrderItem
                                    {
                                       Product = product,
                                       UnitPrice = 10.4m,
                                       Preferences =
                                           {
                                               {"Milk", "skim"},
                                               {"Size", "small"}
                                           }
                                    });
                orderRepository.MakePersistent(order);
                order.Pay("1234", "jose");
                id = order.Id;
                tx.Commit();
            }

            using (var context = m_sessionFactory.OpenSession())
            {
                var repository = new Repository<Order>(context);
                var order = repository.GetById(id);
                order.Satisfy(a_o => a_o.Location == Location.InShop
                                && a_o.Items.Count() == 1
                                && a_o.Payment != null);
            }
        }
        private static IEnumerable<Link> GetLinks(Order order, ResourceLinker linker, NancyContext context)
        {
            var get = new Link(
            linker.BuildUriString(context, "ReadOrder", new {orderId = order.Id}),
            context.Request.BaseUri() + "/docs/order-get.htm",
            MediaTypes.Default);

              var update = new Link(
            linker.BuildUriString(context, "UpdateOrder", new { orderId = order.Id}),
            context.Request.BaseUri() + "/docs/order-update.htm",
            MediaTypes.Default);

              var cancel = new Link(
            linker.BuildUriString(context, "CancelOrder", new { orderId = order.Id}),
            context.Request.BaseUri() + "/docs/order-cancel.htm",
            MediaTypes.Default);

              var pay = new Link(linker.BuildUriString(context, "PayOrder", new {orderId = order.Id}),
            context.Request.BaseUri() + "/docs/order-pay.htm",
            MediaTypes.Default);

              switch (order.Status)
              {
            case OrderStatus.Unpaid:
              yield return get;
              yield return update;
              yield return cancel;
              yield return pay;
              break;
            case OrderStatus.Paid:
            case OrderStatus.Delivered:
              yield return get;
              break;
            case OrderStatus.Ready:
              break;
            case OrderStatus.Canceled:
              yield break;
            default:
              yield break;
              }
        }
Example #15
0
        public void CanChangeStatus()
        {
            long id;
            using (var session = m_sessionFactory.OpenSession())
            using (var tx = session.BeginTransaction())
            {
                var productRepository = new Repository<Product>(session);
                var product = new Product {Name = "Latte", Price = 10.4m};
                productRepository.MakePersistent(product);

                var orderRepository = new Repository<Order>(session);
                var order = new Order
                                {
                                    Date = new DateTime(2011, 1, 1),
                                    Location = Location.InShop,
                                };
                order.AddItem(new OrderItem
                                  {
                                      Product = product,
                                      UnitPrice = 10.4m,
                                      Preferences =
                                          {
                                              {"Milk", "skim"},
                                              {"Size", "small"}
                                          }
                                  });
                orderRepository.MakePersistent(order);
                order.Cancel("cascasas");
                id = order.Id;
                tx.Commit();
            }
            using (var session = m_sessionFactory.OpenSession())
            using (session.BeginTransaction())
            {
                session.Get<Order>(id).Status.Should().Be.EqualTo(OrderStatus.Canceled);
            }
        }
Example #16
0
        public void VersionNumberGrowOnEachUpdate()
        {
            long id;
            int version;
            using (var session = m_sessionFactory.OpenSession())
            using (var tx = session.BeginTransaction())
            {
                var productRepository = new Repository<Product>(session);
                var product = new Product {Name = "Latte", Price = 10.4m};
                productRepository.MakePersistent(product);

                var orderRepository = new Repository<Order>(session);
                var order = new Order
                                {
                                    Date = new DateTime(2011, 1, 1),
                                    Location = Location.InShop,
                                };
                order.AddItem(new OrderItem
                                  {
                                      Product = product,
                                      UnitPrice = 10.4m,
                                      Preferences =
                                          {
                                              {"Milk", "skim"},
                                              {"Size", "small"}
                                          }
                                  });
                orderRepository.MakePersistent(order);
                order.Pay("1234", "jose");
                id = order.Id;

                tx.Commit();
                version = order.Version;
            }
            using (var session = m_sessionFactory.OpenSession())
            using (var tx = session.BeginTransaction())
            {
                var order = session.Get<Order>(id);
                order.Location = Location.TakeAway;
                tx.Commit();

                order.Version.Should().Be.GreaterThan(version);
            }
        }
Example #17
0
 public void IfTheOrderDoesNotHaveItems_ThenReturnInvalidMessage()
 {
     var order = new Order();
     order.GetErrorMessages()
         .Should().Contain("The order must include at least one item.");
 }
Example #18
0
 public void save(Order order)
 {
     var order_count = orders.Count;
     order.id = order_count + 1;
     orders.Add(order);
 }
        public ActionResult Save(FormCollection form_collection)
        {
            //Save Order
            var order_repository = (OrderRepository)System.Web.HttpContext.Current.Application["order_repository"];
            var order_items = (IList<OrderItemModel>)Session["order_items"];
            var order = new Order();

            foreach (var order_item in order_items)
            {
                var item = new OrderItem {item_id = order_item.item_id, quantity = order_item.quantity, price = order_item.price};
                order.items.Add(item);
            }

            order_repository.save(order);

            //Send email
            MailMessage email = new MailMessage("*****@*****.**","*****@*****.**");
            email.Subject = "Order submitted";

            SmtpClient client = new SmtpClient("localhost");

            try
            {
                client.Send(email);
            }
            catch(Exception exception)
            {
                //It is ok that it doesn't actually send the email for this project
            }

            ViewData["order"] = order;
            return View("ThankYou");
        }
Example #20
0
 public void AddOrder(Order order)
 {
     _context.Orders.Add(order);
 }
Example #21
0
 public void AddOrder(Order order)
 {
     order.Id = _orders.Count;
     _orders.Add(order);
 }
Example #22
0
 public void UpdateOrder(Order order)
 {
     _context.Entry(order).CurrentValues.SetValues(order);
 }