Beispiel #1
0
        public void UpdateShippingCosts(UpdateShippingCostsRequest data)
        {
            using (var db = new Entities())
            {

                foreach (var country in data.Countries)
                {
                    foreach (var cost in country.ShippingCosts)
                    {
                        var shippingCost = db.ShippingCosts.SingleOrDefault(sc => sc.CountryId == country.Id && sc.ShippingCategoryId == cost.ShippingCategoryId);
                        if (shippingCost != null)
                        {
                            shippingCost.Amount = cost.Amount;
                            shippingCost.AdditionalAmount = cost.AdditionalAmount;
                            db.Entry(shippingCost).State = EntityState.Modified;
                        }
                        else
                        {
                            shippingCost = new ShippingCost
                            {
                                CountryId = country.Id,
                                ShippingCategoryId = cost.ShippingCategoryId,
                                Amount = cost.Amount,
                                AdditionalAmount = cost.AdditionalAmount
                            };

                            db.ShippingCosts.Add(shippingCost);
                        }
                    }
                }

                db.SaveChanges();
            }
        }
Beispiel #2
0
        public void Add_the_same_Product_to_Cart()
        {
            using (var db = new Entities())
            {
                var sut = _createSut();

                AssertChangedBy(db.LineItems, () =>
                {
                    var cart = sut.CreateCart();
                    // Add product once...
                    var product = db.Products.First();
                    var lineItemId = sut.AddProduct(cart.Id, product.Id, 17);
                    // Add same product a second time.
                    var lineItem2Id = sut.AddProduct(cart.Id, product.Id, 1);

                    // Assert
                    cart = sut.GetCart(cart.Id);
                    Assert.AreEqual(1, cart.LineItems.Count());
                    Assert.AreEqual(product.Id, cart.LineItems.First().ProductId);
                    Assert.AreEqual(18, cart.LineItems.First().Qty);
                    Assert.AreNotEqual(0, lineItemId);
                    Assert.AreEqual(lineItem2Id, lineItemId);
                });
            }
        }
        public void Update_product()
        {
            var sut = _createSut();
            using (var db = new Entities()) {
                AssertChangedBy(db.Products, () =>
                {
                    // Act
                    sut.UpdateProduct(5, new Llprk.Application.DTOs.Responses.UpdateProductRequest {
                        Available = 10,
                        Description = "descr",
                        IsPublished = true,
                        MetaDescription = "meta",
                        Name = "name",
                        PageTitle = "title",
                        Price = 17.99m,
                        ShippingCategoryId = db.ShippingCategories.First().Id,
                        UrlHandle = "handle"
                    });

                    // Assert
                    var prod = db.Products.Single(p => p.Id == 5);
                    Assert.AreEqual(10, prod.Available);
                    Assert.AreEqual("descr", prod.Description);
                    Assert.AreEqual(true, prod.IsPublished);
                    Assert.AreEqual("meta", prod.MetaDescription);
                    Assert.AreEqual("name", prod.Name);
                    Assert.AreEqual("title", prod.PageTitle);
                    Assert.AreEqual(17.99m, prod.Price);
                    Assert.AreEqual(db.ShippingCategories.First().Id, prod.ShippingCategoryId);
                    Assert.AreEqual("handle", prod.UrlHandle);
                }, 0);
            }
        }
        public void Update_Shipping_Costs_simple()
        {
            using (var db = new Entities())
            {
                var sut = _createSut();
                var scId = db.ShippingCategories.First().Id;

                using (new TransactionScope())
                {
                    sut.UpdateShippingCosts(new UpdateShippingCostsRequest
                    {
                        Countries = new UpdateShippingCostsRequest.Country[] {
                        new UpdateShippingCostsRequest.Country {
                            Id = "at",
                            ShippingCosts = new UpdateShippingCostsRequest.ShippingCost[] {
                                new UpdateShippingCostsRequest.ShippingCost {
                                    ShippingCategoryId = scId,
                                    Amount = 9, AdditionalAmount = 10
                                }
                            }
                        }
                    }
                    });

                    Assert.AreEqual(9, db.Countries.Single(c => c.Id == "at").ShippingCosts.Single(s => s.ShippingCategoryId == scId).Amount);
                }
            }
        }
Beispiel #5
0
        public int AddProduct(int cartId, int productId, int qty)
        {
            using (var db = new Entities())
            {
                var product = db.Products.Single(p => p.Id == productId);
                // Find lineitem with this product.
                var lineItem = product.LineItems.SingleOrDefault(li => li.CartId == cartId);

                if (lineItem != null)
                {
                    lineItem.Qty += qty;
                }
                else
                {
                    lineItem = new LineItem
                    {
                        CartId = cartId,
                        ProductId = productId,
                        Qty = qty,
                        Price = product.Price
                    };

                    db.LineItems.Add(lineItem);
                }
                db.SaveChanges();

                return lineItem.Id;
            }
        }
        public void Create_Order_simple()
        {
            using (var db = new Entities())
            {
                var sut = _createSut();
                var address = new CreateOrderRequest.Address {
                    Address1 = "Address1",
                    Address2 = "Address2",
                    City = "City",
                    CountryId = "at",
                    Email = "*****@*****.**",
                    Firstname = "Firstname",
                    Lastname = "Lastname",
                    Salutation = "Salut",
                    Zip = "1234"
                };
                var request = new CreateOrderRequest
                {
                    DeliveryAddress = address,
                };

                AssertChangedBy(db.Orders, () =>
                {
                    var order = sut.CreateOrder(3, request);
                    Assert.IsNotNull(order);
                });
            }
        }
Beispiel #7
0
        /// <summary>
        /// Get infos to start editing a page.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public EditProductResponse GetProductForEdit(int id)
        {
            using (var db = new Llprk.DataAccess.Models.Entities()) {
                var product = _GetProduct(db, id);

                return(Mapper.Map <EditProductResponse>(product));
            }
        }
Beispiel #8
0
        /// <summary>
        /// Get infos to start editing a page.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public EditPageRequest GetPageForEdit(int id)
        {
            using(var db = new Llprk.DataAccess.Models.Entities()) {
                var page = _GetPage(db, id);

                return Mapper.Map<EditPageRequest>(page);
            }
        }
Beispiel #9
0
        /// <summary>
        /// Get infos to start editing a page.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public EditPageRequest GetPageForEdit(int id)
        {
            using (var db = new Llprk.DataAccess.Models.Entities()) {
                var page = _GetPage(db, id);

                return(Mapper.Map <EditPageRequest>(page));
            }
        }
Beispiel #10
0
        /// <summary>
        /// Get infos to start editing a page.
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public EditProductResponse GetProductForEdit(int id)
        {
            using(var db = new Llprk.DataAccess.Models.Entities()) {
                var product = _GetProduct(db, id);

                return Mapper.Map<EditProductResponse>(product);
            }
        }
Beispiel #11
0
 public Cart GetCart(int id)
 {
     using (var db = new Entities())
     {
         return db.Carts
             .Include(i => i.LineItems.Select(l => l.Product))
             .SingleOrDefault(c => c.Id == id);
     }
 }
Beispiel #12
0
 public void UpdateShippingCategory(int id, string name)
 {
     using (var db = new Entities())
     {
         var category = db.ShippingCategories.Single(c => c.Id == id);
         category.Name = name;
         db.Entry(category).State = EntityState.Modified;
         db.SaveChanges();
     }
 }
Beispiel #13
0
        public Cart CreateCart()
        {
            using (var db = new Entities())
            {
                var cart = new Cart();
                db.Carts.Add(cart);
                db.SaveChanges();

                return cart;
            }
        }
Beispiel #14
0
        /// <summary>
        /// Get the requested Product.
        /// </summary>
        /// <param name="db"></param>
        /// <param name="id"></param>
        /// <returns>throws ArguementException if not found.</returns>
        private Product _GetProduct(Llprk.DataAccess.Models.Entities db, int id)
        {
            var result = db.Products.SingleOrDefault(p => p.Id == id);

            if (result == null)
            {
                throw new ArgumentException(string.Format("Cannot find product ({0})!", id));
            }

            return(result);
        }
Beispiel #15
0
 /// <summary>
 /// Show Tax settings and taxes.
 /// </summary>
 /// <returns></returns>
 public virtual ActionResult Index()
 {
     using (var db = new Entities())
     {
         var vm = new TaxIndex
         {
             Countries = Mapper.Map<TaxIndex.Country[]>(db.Countries)
         };
         return View(vm);
     }
 }
Beispiel #16
0
        /// <summary>
        /// Update product.
        /// </summary>
        /// <param name="request"></param>
        public void UpdateProduct(int id, UpdateProductRequest request)
        {
            if (request == null) throw new ArgumentNullException("request");

            using(var db = new Llprk.DataAccess.Models.Entities()) {
                var product = _GetProduct(db, id);

                Mapper.Map(request, product);
                db.Entry(product).State = System.Data.Entity.EntityState.Modified;
                db.SaveChanges();
            }
        }
 /// <summary>
 /// Show shipping costs.
 /// </summary>
 /// <returns></returns>
 public virtual ActionResult Index() 
 {
     using (var db = new Entities())
     {
         var vm = new ShippingCostIndex
         {
             Countries = Mapper.Map<ShippingCostIndex.Country[]>(db.Countries),
             ShippingCategories = Mapper.Map<ShippingCostIndex.ShippingCategory[]>(db.ShippingCategories)
         };
         return View(vm);
     }
 }
Beispiel #18
0
        /// <summary>
        /// Creates a new page.
        /// </summary>
        /// <param name="info"></param>
        public void CreatePage(NewPageResponse info)
        {
            using (var db = new Entities())
            {
                var page = Mapper.Map<Page>(info);
                page.CreatedAt = DateTime.Now;

                db.Pages.Add(page);
                db.SaveChanges();
            }

        }
        public void Create_ShippingCategory()
        {
            using (var db = new Entities())
            {
                var sut = _createSut();

                AssertChangedBy(db.ShippingCategories, () =>
                {
                    sut.CreateShippingCategory("_delme");
                });
            }
        }
Beispiel #20
0
        public void Get_Cart()
        {
            using (var db = new Entities())
            {
                var sut = _createSut();

                var cart = sut.GetCart(3);

                Assert.IsNotNull(cart);
                Assert.AreEqual(3, cart.Id);
            }
        }
Beispiel #21
0
        public void Create_Cart()
        {
            using (var db = new Entities())
            {
                var sut = _createSut();

                AssertChangedBy(db.Carts, () =>
                {
                    var cart = sut.CreateCart();
                    Assert.IsNotNull(cart);
                });
            }
        }
        public void Delete_ShippingCategory()
        {
            using (var db = new Entities())
            {
                var sut = _createSut();

                AssertChangedBy(db.ShippingCategories, () =>
                {
                    var cat = sut.CreateShippingCategory("tester");

                    sut.DeleteShippingCost(cat.Id);
                }, 0);
            }
        }
Beispiel #23
0
        /// <summary>
        /// Update page with given infos.
        /// </summary>
        /// <param name="info"></param>
        public void UpdatePage(EditPageResponse info)
        {
            if (info == null) throw new ArgumentNullException("info");

            using (var db = new Llprk.DataAccess.Models.Entities())
            {
                var page = _GetPage(db, info.Id);

                Mapper.Map(info, page);
                db.Entry(page).State = System.Data.Entity.EntityState.Modified;

                db.SaveChanges();
            }
        }
Beispiel #24
0
        public ShippingCategory CreateShippingCategory(string name)
        {
            using (var db = new Entities())
            {
                var cat = new ShippingCategory
                {
                    Name = name
                };

                db.ShippingCategories.Add(cat);
                db.SaveChanges();

                return cat;
            }
        }
Beispiel #25
0
        /// <summary>
        /// Update product.
        /// </summary>
        /// <param name="request"></param>
        public void UpdateProduct(int id, UpdateProductRequest request)
        {
            if (request == null)
            {
                throw new ArgumentNullException("request");
            }

            using (var db = new Llprk.DataAccess.Models.Entities()) {
                var product = _GetProduct(db, id);

                Mapper.Map(request, product);
                db.Entry(product).State = System.Data.Entity.EntityState.Modified;
                db.SaveChanges();
            }
        }
Beispiel #26
0
 public void DeleteShippingCost(int id)
 {
     try
     {
         using (var db = new Entities())
         {
             var cat = db.ShippingCategories.Single(c => c.Id == id);
             db.ShippingCategories.Remove(cat);
             db.SaveChanges();
         }
     }
     catch (DbUpdateException)
     {
         throw new ApplicationException("Shipping category is in use. Cannot delete it.");
     }
 }
Beispiel #27
0
        /// <summary>
        /// Update page with given infos.
        /// </summary>
        /// <param name="info"></param>
        public void UpdatePage(EditPageResponse info)
        {
            if (info == null)
            {
                throw new ArgumentNullException("info");
            }

            using (var db = new Llprk.DataAccess.Models.Entities())
            {
                var page = _GetPage(db, info.Id);

                Mapper.Map(info, page);
                db.Entry(page).State = System.Data.Entity.EntityState.Modified;

                db.SaveChanges();
            }
        }
        public void Update_ShippingCategory()
        {
            using (new TransactionScope())
            {
                int catId = 0;
                using (var db = new Entities())
                {
                    var sut = _createSut();

                    catId = db.ShippingCategories.First().Id;
                    sut.UpdateShippingCategory(catId, "das ist ein test");
                }

                // Komisch: Damit die geänderte Kateogrie auch wirklich geladen wird, muss der EF-Kontext
                //          neu erstellt werden. Identity-Map schlägt zu? Warum nur hier?
                using (var db = new Entities())
                {
                    Assert.AreEqual("das ist ein test", db.ShippingCategories.Single(c => c.Id == catId).Name);
                }
            }
        }
        public void Execute() {
            using (var db = new Entities()) {
				// Welche Bestellungen müssen den geändert werden?
                var ordersToUpdate = db.Orders
                                        .Include(o => o.OrderLines)
                                        .Include("OrderLines.Product")
                                        .Include("OrderLines.Product.ShippingCategory")
                                        .Where(o => o.SubTotalPrice == 0 || o.ShippingCosts == 0)
                                        .ToList();

				var shopService = new ShopService();

				// Für die gewählten Bestellungen die Preise berechnen...
                foreach (var order in ordersToUpdate) {
                    order.SubTotalPrice = shopService.CalculateSubTotalPrice(order);
                    order.ShippingCosts = shopService.CalculateShippingCosts(order);
                }

				// ...und speichern.
                db.SaveChanges();
            }	
        }
Beispiel #30
0
        /// <summary>
        /// Update the tax for a single country.
        /// </summary>
        /// <param name="country"></param>
        /// <param name="percent"></param>
        public void UpdateCountryTax(string country, int percent)
        {
            using (var db = new Entities())
            {
                var tax = db.Taxes.SingleOrDefault(t => t.CountryId == country);

                if (tax == null)
                {
                    tax = new Tax
                    {
                        CountryId = country,
                        Percent = percent
                    };
                    db.Taxes.Add(tax);
                }
                else
                {
                    tax.Percent = percent;
                }

                db.SaveChanges();
            }
        }
Beispiel #31
0
        public decimal TaxForCountry(int cartId, string country)
        {
            using (var db = new Entities())
            {
                var cart = db.Carts
                    .Include(i => i.LineItems.Select(l => l.Product))
                    .Single(c => c.Id == cartId);
                var cnt = db.Countries
                    .Include(i => i.Taxes)
                    .Single(c => c.Id == country);

                return cart.LineItems.Sum(li =>
                {
                    if (li.Product.ChargeTaxes)
                    {
                        return li.Subtotal - (li.Subtotal / ((100.0m + cnt.Taxes.First().Percent) / 100.0m));
                    }
                    else
                    {
                        return 0;
                    }
                });
            }
        }
Beispiel #32
0
        /// <summary>
        /// Bestellung abgeben.
        /// </summary>
        /// <param name="order"></param>
        /// <param name="productIdsAndQtys"></param>
        public void PlaceOrder(Entities db, Order order, IDictionary<int, int> productIdsAndQtys)
        {
            using (var transaction = new TransactionScope()) {
                // Bestellung mit Datum versehen und in DB speichern.
                order.CreatedAt = DateTime.Now;
				// Die Bestellung muss erstmal ohne Bestellzeilen gespeichert werden,
				// damit wir eine BestellID aus der DB haben.
                db.Orders.Add(order);
                db.SaveChanges();

                foreach (var id in productIdsAndQtys.Keys) {
                    var product = db.Products
                        .Include(p => p.ShippingCategory) // Brauchen wird für die Versandkostenberechnung.
                        .FirstOrDefault(x => x.Id == id);
                    var qty = productIdsAndQtys[id];
                    if (product == null) {
                        throw new AppException(string.Format(
                            "Das Produkt mit der Id {0} ist nicht verfügbar!",
                            id));
                    }
                    // Nicht mehr genug vom Produkt auf Lager?
                    if (product.Available < qty) {
                        throw new AppException(string.Format(
                            "Von {0} ist/sind nur noch {1} Stück auf Lager. Bitte Menge anpassen.",
                            product.Name,
                            product.Available));
                    }

                    // Menge abziehen.
                    product.Available -= qty;

                    // Produkte zur Bestellung hinzufügen.
                    order.OrderLines.Add(new OrderLine() {
                        OrderId = order.Id,
                        ProductId = id,
						Product = product,
                        Qty = qty
                    });
                }
				// ...speichern.
                db.SaveChanges();

				// Preis berechnen
                order.SubTotalPrice = CalculateSubTotalPrice(order);
				// Versandkosten berechnen
                order.ShippingCosts = CalculateShippingCosts(order);

                // Validierung.
                var vc = new ValidationContext(order, null, null);
                Validator.ValidateObject(order, vc, true);

				// ...speichern.
                db.SaveChanges();

                // Bestätigungsmail verschicken.
                var mailBody = Nustache.Core.Render.StringToString(db.Parameters.First().MailMessageOrdered, order);
                MailService.SendMailToCustomer(order.Email, "Deine Bestellung bei lillypark.com", mailBody);

                transaction.Complete();
            }

			// Benachrichtgung an den Shopinhaber, dass eine neue
			// Bestellung eingegangen ist.
			// INFO: Wenn das Verschicken fehlschlägt, soll die Bestellung dennoch angenommen werden.
            var ownerMailBody = string.Format(@"
Hi Lilly/Hoonie,

guckst Du <a href=""http://lillypark.com/orders/details/{0}"">hier</a>.

Liebe Grüße,

Dein WebShop", order.Id);
            MailService.SendMailToOwner("Eine neue Bestellung ist eingegangen.", ownerMailBody);
        }
Beispiel #33
0
        /// <summary>
        /// Markiert einen Auftrag als verschickt.
        /// </summary>
        /// <param name="order"></param>
        public void ShipOrder(Entities db, Order order, string mailBody)
        {
            if (order == null) { throw new ArgumentNullException("order"); }

            order.ShippedAt = DateTime.Now;

            // Email an den Kunden schicken.
            MailService.SendMailToCustomer(order.Email, "Deine Bestellung wurde verschickt", mailBody);
            db.SaveChanges();
        }
Beispiel #34
0
        /// <summary>
        /// Markiert einen Auftrag als bezahlt.
        /// </summary>
        /// <param name="order"></param>
        public void PayOrder(Entities db, Order order, string mailBody=null)
        {
            if (order == null) { throw new ArgumentNullException("order"); }

            order.PaidAt = DateTime.Now; // TODO: Vielleicht hat der Kunde schon vorher gezahlt?

			// Wenn kein Bestätigungs-Mail-Body angegeben wurde, 
			// müssen wir den selber erstellen.
            var body = mailBody == null
                ? Nustache.Core.Render.StringToString(db.Parameters.First().MailMessagePaid, order)
                : mailBody;

            // Email an den Kunden schicken.
            MailService.SendMailToCustomer(order.Email, "Wir haben Deine Bezahlung erhalten", body);

            db.SaveChanges();
        }
Beispiel #35
0
        public void UpdateLineItemQty(int cartId, UpdateLineItemQtyRequest[] updates)
        {
            using (var db = new Entities())
            {

                foreach (var update in updates)
                {
                    var lineItem = db.LineItems.Single(l => l.Id == update.Id);
                    if (update.Qty == 0)
                    {
                        db.LineItems.Remove(lineItem);
                    }
                    else
                    {
                        lineItem.Qty = update.Qty;
                        db.Entry(lineItem).State = System.Data.Entity.EntityState.Modified;
                    }
                }

                db.SaveChanges();
            }
        }