/// <summary>
/// Initializes a new instance of the <see cref="CurrentDiscounts"/> class.
/// </summary>
/// <param name="basket">The <see cref="BasketModel"/>.</param>
public CurrentDiscounts(BasketModel basket)
{
if (basket == null)
throw new ArgumentNullException(nameof(basket));
_basket = basket;
}
/// <summary>
/// Adds the <paramref name="items" /> to the basket.
/// </summary>
/// <param name="items">
/// An <see cref="IEnumerable{TEntity}" /> of <see cref="BasketItemModel" /> entities to add to the basket.
/// </param>
/// <returns>The updated <see cref="BasketModel" /></returns>
public BasketModel AddBasketItems(IEnumerable<BasketItemModel> items)
{
if (items == null)
throw new ArgumentNullException(nameof(items));
foreach (var item in items)
{
AddBasketItem(item);
}
_basket = _currentDiscounts.Run();
return _basket;
}
public ActionResult RemoveFromCart(int id, int quantity, int size)
{
if (!(Session["Basket"] is BasketModel))
{
Session["Basket"] = new BasketModel();
}
ProductModel product = new ProductModel(DataHelper.GetProduct(id));
BasketModel model = ((BasketModel)Session["Basket"]);
BasketItem item = model.Where(x => x.Product.ID == id && x.Quantity == quantity && x.Size == size).FirstOrDefault();
if (item != null)
{
model.Remove(item);
}
return RedirectToAction("Index");
}
public IActionResult Index()
{
List <BasketItemModel> basketItems = new List <BasketItemModel>();
ShoppingCartSummary cartSummary = GetCartSummary();
BasketModel model;
BaseModelData modelData = GetModelData();
if (cartSummary.Id != 0)
{
ShoppingCartDetail cartDetails = _shoppingCartProvider.GetDetail(cartSummary.Id);
_stockProvider.GetStockAvailability(cartDetails.Items);
foreach (ShoppingCartItem item in cartDetails.Items)
{
basketItems.Add(new BasketItemModel(GetModelData(),
item.Id, item.Name, item.Description,
item.Size, item.SKU, item.ItemCost, (int)item.ItemCount,
item.StockAvailability > 500 ? "> 500" : item.StockAvailability.ToString(),
item.ItemCount * item.ItemCost, false, item.Images[0]));
}
if (TempData.ContainsKey("VoucherError"))
{
ModelState.AddModelError(nameof(VoucherModel.Voucher), Languages.LanguageStrings.VoucherInvalid);
TempData.Remove("VoucherError");
}
modelData.ReplaceCartSummary(cartSummary);
model = new BasketModel(modelData, basketItems,
cartDetails.CouponCode, cartDetails.RequiresShipping,
!String.IsNullOrEmpty(GetUserSession().UserEmail));
}
else
{
modelData.ReplaceCartSummary(cartSummary);
model = new BasketModel(modelData, new List <BasketItemModel>(),
String.Empty, false, GetUserSession().UserID != 0);
}
return(View(model));
}
public async Task <IActionResult> AddToBasket(int id)
{
var logEntity = new BasEntity();
List <BasketModel> perfumes = HttpContext.Session.GetObject <List <BasketModel> >("basket");
var userName = HttpContext.Session.GetString("userName");
var perfumeToAdd = await _perfumeApiService.GetAsync(id);
if (perfumes == null)
{
perfumes = new List <BasketModel>();
}
var result = (from item in perfumes
where item.PerfumeId == perfumeToAdd.PerfumeId
select item).FirstOrDefault();
if (result == null)
{
BasketModel model = new BasketModel
{
PerfumeId = perfumeToAdd.PerfumeId,
PerfumeName = perfumeToAdd.PerfumeName,
Price = perfumeToAdd.Price,
Count = 1
};
perfumes.Add(model);
logEntity.PerfumeName = model.PerfumeName;
logEntity.PerfumeCount = model.Count;
}
else
{
result.Count++;
logEntity.PerfumeName = result.PerfumeName;
logEntity.PerfumeCount = result.Count;
}
AddToCartPrintLogMessage(logEntity.PerfumeName, logEntity.PerfumeCount, userName);
HttpContext.Session.SetObject("basket", perfumes);
return(RedirectToAction("GetAll", "Perfume"));
}
public async Task ApplyDiscount_ReturnOk()
{
//Arrange
List <BasketProductModel> expectedProducts = new List <BasketProductModel> {
new BasketProductModel()
{
ProductName = "Milk",
ProductPrice = 1.15,
Quantity = 2,
Total = 2.30,
OfferForThisProduct = new OfferModel
{
IsFree = true,
OfferName = "Milk",
OfferTriggerFrom = "Milk"
}
}
};
BasketModel basketModel = new BasketModel {
Products = expectedProducts
};
var milk = new BasketProductModel()
{
ProductName = "Milk",
ProductPrice = 1.15,
Quantity = 1,
OfferForThisProduct = new OfferModel
{
IsFree = true,
OfferName = "Milk",
OfferTriggerFrom = "Milk"
}
};
//Act
var resultBasket = await subject.ApplyDiscount(basketModel, milk);
//Assert
Assert.AreEqual(expectedProducts[0].Total, resultBasket.Products[0].Total);
Assert.AreEqual(expectedProducts[0].Quantity, resultBasket.Products[0].Quantity);
}
public async Task <bool> UpdateAsync(BasketModel basket)
{
Guid.TryParse(basket.UserId, out Guid userId);
var item = _applicationDbContext.Basket.SingleOrDefault(b => b.UserId == userId);
if (item != null)
{
var updatedBasket = _mapper.Map <Basket>(basket);
_applicationDbContext.Update(updatedBasket);
}
else
{
var newBasket = _mapper.Map <Basket>(basket);
_applicationDbContext.Basket.Add(newBasket);
}
var result = await _applicationDbContext.SaveChangesAsync();
return(result != 0);
}
public void CalculateBasket_ShouldReturnInCorrectBasketTotal_WhenCalculationCompleted()
{
var basketId = Guid.NewGuid();
var basketDto = new BasketModel
{
Id = basketId,
SubTotal = Convert.ToDecimal(440),
CouponTotal = Convert.ToDecimal(55),
DeliveryPrice = Convert.ToDecimal(11.1),
DiscountTotal = Convert.ToDecimal(20.3)
};
BasketOperations.BasketList.Add(basketDto);
//Act
var result = _basketOperations.CalculateBasket(basketId);
//Assert
Assert.NotEqual(result.BasketTotal, Convert.ToDecimal(275.8));
}
/// <summary>
/// Takes the user input basket and adds the item to the GroceryKiosk BasketModel.
/// </summary>
/// <param name="userBasket"></param>
/// <param name="kioskItems"></param>
/// <returns></returns>
public static BasketModel GetItemAndAddOrUpdateBasket(string[] userBasket, List <ItemModel> kioskItems)
{
BasketModel basket = new BasketModel();
foreach (var itemName in userBasket)
{
ItemModel item =
kioskItems.FirstOrDefault(
x => string.Equals(x.ItemName, itemName, StringComparison.CurrentCultureIgnoreCase));
if (item == null)
{
continue;
}
BasketItemModel basketItem = new BasketItemModel(item);
basket.AddOrUpdateBasket(basketItem);
}
return(basket);
}
public async void PostReturnsCreatedAtResult()
{
var basket = new BasketModel {
Id = Guid.NewGuid(), UserId = Guid.NewGuid()
};
manager.Setup(x => x.Create(basket.UserId)).Returns(Task.FromResult(basket));
var result = await controller.Post(basket);
var createdAtResult = Assert.IsType <CreatedAtActionResult>(result.Result);
Assert.Equal(nameof(BasketController.Get), createdAtResult.ActionName);
Assert.True(createdAtResult.RouteValues.TryGetValue("id", out Object basketId));
Assert.Equal(basket.Id, basketId);
var basketResult = Assert.IsType <BasketModel>(createdAtResult.Value);
Assert.Equal(basket.Id, basketResult.Id);
Assert.Equal(basket.UserId, basketResult.UserId);
}
/// <summary>
/// Vloží existující zboží do košíku
/// </summary>
/// <param name="product">Parametry vkládaného zboží</param>
public void AddProduct(BasketModel product)
{
//!!! Kontrola vyjímek zde (chyba serveru) !!!
// Vložení nového itemu do košíku
using (SqlConnection pripojeni = new SqlConnection(connectionString)) // Deklarace pripojení
{
// Dotaz se selectem
SqlCommand insert = new SqlCommand("mp_pridej_produkt @Kosik_id, @Product, @Pocet_ks ", pripojeni);
insert.Parameters.AddWithValue("@Kosik_id", 1);
insert.Parameters.AddWithValue("@Product", product.Produkt);
insert.Parameters.AddWithValue("@Pocet_ks", product.Ks);
//insert.Parameters.Add("@newID", SqlDbType.Int, 0).Direction = ParameterDirection.Output; // Pro výstupní parametr procedury
// Otevření spojení
pripojeni.Open();
// Provedení příkazu
insert.ExecuteNonQuery();
}
}
public ActionResult AddGameToBasket(string key, int quantity = 1)
{
GameModel gameModel = _gameService.GetGameModelByKey(key);
string sessionKey = Session.SessionID;
BasketModel basketModel = _basketService.GetBasketModelForUser(sessionKey);
var basketItemModel = new BasketItemModel
{
BasketId = basketModel.BasketId,
Quantity = quantity,
Price = gameModel.Price,
Discount = 0,
GameId = gameModel.GameId,
Game = Mapper.Map <GameModel>(gameModel)
};
_basketService.AddBasketItem(basketItemModel);
MessageSuccess("The game has been added to your basket.");
return(RedirectToAction("Get", "Basket"));
}
private BasketModel BuildBasket(int milkQty, int breadQty, int butterQty)
{
//Butter £0.80
//Milk £1.15
//Bread £1.00
var basket = new BasketModel();
if (milkQty > 0)
{
basket.Items.Add(new BasketItemModel
{
ItemId = Item.MilkId,
Quantity = milkQty,
UnitPrice = Item.MilkPrice
});
}
if (breadQty > 0)
{
basket.Items.Add(new BasketItemModel
{
ItemId = Item.BreadId,
Quantity = breadQty,
UnitPrice = Item.BreadPrice
});
}
if (butterQty > 0)
{
basket.Items.Add(new BasketItemModel
{
ItemId = Item.ButterId,
Quantity = butterQty,
UnitPrice = Item.ButterPrice
});
}
return(basket);
}
public void CalculateTotalDeliveryPrice_ShouldReturnInCorrectValue_WhenCalculationCompleted()
{
//Arrange
var categoryId = Guid.NewGuid();
var categoryTitle = "Technology";
var categoryDto = new CategoryModel
{
Id = categoryId,
Title = categoryTitle
};
Dictionary <ProductModel, int> productDictionary = new Dictionary <ProductModel, int>();
var productId = Guid.NewGuid();
var productTitle = "Mobile Phone";
var productAmount = 1;
var productDto = new ProductModel
{
Id = productId,
Title = productTitle,
Category = categoryDto,
Price = 4900
};
productDictionary.Add(productDto, productAmount);
var basketId = Guid.NewGuid();
var basketDto = new BasketModel
{
Id = basketId,
Products = productDictionary
};
BasketOperations.BasketList.Add(basketDto);
//Act
var result = _basketOperations.CalculateTotalDeliveryPrice(basketDto);
//Assert
Assert.NotEqual(result, Decimal.One);
}
public BasketSummaryViewModel GetBasketSummary(HttpContextBase httpContext)
{
BasketModel basket = GetBasket(httpContext, false);
BasketSummaryViewModel model = new BasketSummaryViewModel(0, 0);
if (basket != null)
{
int?basketCount = (from item in basket.BasketItems
select item.Quantity
).Sum();
decimal?basketTotal = (from item in basket.BasketItems
join p in productContext.Collection() on item.ProductId equals p.Id
select item.Quantity *p.Price
).Sum();
model.BasketCount = basketCount ?? 0;
model.BasketTotal = basketTotal ?? decimal.Zero;
}
return(model);
}
public async Task <BasketModel> GetBasketItems(Microsoft.AspNetCore.Http.HttpRequest httpRequest)
{
BasketModel basket = new BasketModel();
try
{
string cookie;
if (httpRequest.Cookies.TryGetValue("Cart", out cookie))
{
if (cookie != null)
{
var basketInfo = Barayand.Common.Services.CryptoJsService.DecryptStringAES(cookie);
basket = JsonConvert.DeserializeObject <BasketModel>(basketInfo);
}
}
return(basket);
}
catch (Exception ex)
{
return(basket);
}
}
public void TestApplyingOnePromotionToBasketWithTwoDifferentItems()
{
List <PromotionModel> promotions = new List <PromotionModel> {
_appleDiscount
};
BasketItemModel appleBasketItem = new BasketItemModel(_apple);
BasketItemModel orangeBasketItem = new BasketItemModel(_orange);
BasketModel basket = new BasketModel();
basket.AddOrUpdateBasket(appleBasketItem);
basket.AddOrUpdateBasket(orangeBasketItem);
IPromotionService promotionService = new PromotionService();
promotionService.ApplyPromotionsToBasket(basket, promotions);
Assert.AreEqual(2, basket.Basket.Count);
Assert.AreEqual(3, basket.Total);
Assert.IsTrue(basket.Basket[0].Discount != null);
Assert.AreEqual("Apple", basket.Basket[0].ItemName);
Assert.IsTrue(basket.Basket[1].Discount == null);
Assert.AreEqual("Orange", basket.Basket[1].ItemName);
Assert.AreEqual(0.5M, basket.Basket[0].Discount.TotalDiscountAmount);
}
public IHttpActionResult AddItem([FromBody] AddItemModel model)
{
var basketId = model.BasketId;
if (model.BasketId == Guid.Empty)
{
basketId = Guid.NewGuid();
_commandDispatcher.ExecuteCommand <BasketAggregate>(new CreateBasket(basketId));
}
// TODO: get model price and name from api by id
var cmd = new AddItemToBasket(
basketId,
model.ProductId,
model.Name,
model.Price,
model.Quantity);
var basket = _commandDispatcher.ExecuteCommand <BasketAggregate>(cmd);
return(Ok(BasketModel.FromAggregate(basket)));
}
public void AddNewItemExists()
{
BasketService basketService = new BasketService();
BasketModel basketModel = basketService.CreateNewBasket("C123");
BasketItemModel basketItemModel = new BasketItemModel();
basketItemModel.Id = "111";
basketItemModel.Name = "Car";
basketItemModel.Quantity = 1;
basketItemModel.UnitPrice = (float)5.50;
bool isAdded = basketService.AddBasketItem("C123", basketModel.Id, basketItemModel);
basketItemModel = new BasketItemModel();
basketItemModel.Id = "111";
basketItemModel.Name = "Car";
basketItemModel.Quantity = 1;
basketItemModel.UnitPrice = (float)5.50;
bool isAddedAgain = basketService.AddBasketItem("C123", basketModel.Id, basketItemModel);
//If item already exists, check the API does not add the item again as its quantity must be updated
Assert.False(isAddedAgain);
}
public JsonResult CreateProductBasket(int id, int adet)
{
Product prod = productRepo.SelectById(id);
ProductImage productImage = productImageRepo.FirstByProductId(id);
BasketModel urun = new BasketModel();
urun.ProductName = prod.ProductName;
urun.Piece = adet;
urun.Price = prod.ProductPrice;
urun.ShortDescription = prod.ProductShortDescription;
urun.CargoPrice = prod.CargoPrice;
urun.PhotoPath = productImage.Path;
urun.ProductId = id;
if (Session["sepet"] == null)
{
BasketRepository sepetim = new BasketRepository();
sepetim.Ekle(urun);
Session["sepet"] = sepetim;
}
else
{
if (SepetteVarmi(urun.ProductId) == 1)
{
int idd = urun.ProductId;
BasketRepository sepetim = (BasketRepository)Session["sepet"];
sepetim.urunler[idd].Piece += urun.Piece;
Session["sepet"] = sepetim;
}
else
{
BasketRepository sepetim = (BasketRepository)Session["sepet"];
sepetim.Ekle(urun);
Session["sepet"] = sepetim;
}
}
return(Json(new { success = true, responseText = "Sepete eklenmiştir." }, JsonRequestBehavior.AllowGet));
}
/// <summary>
/// Calculating discount
/// </summary>
/// <param name="basket"></param>
/// <param name="product"></param>
public void CalculateDiscount(ref BasketModel basket, BasketProductModel product)
{
var productContained = NumberOfProductsInBasket(ref basket, _obj);
var obj = basket.Products.FirstOrDefault(x => x.ProductName == _obj.ProductName);
CalculateTotal(ref obj, false);
var exists = basket.Products.Select(x => x.ProductName == obj?.OfferForThisProduct?.OfferTriggerFrom).FirstOrDefault();
var productWithOfferQuanity = basket.Products.FirstOrDefault(prod => prod.ProductName == obj?.OfferForThisProduct?.OfferTriggerFrom);
switch (_obj.ProductName)
{
case "Milk":
obj.Freebies = numberOfFreeItems(productWithOfferQuanity.Quantity);
CalculateTotal(ref obj, true);
break;
case "Butter":
break;
case "Bread":
if (exists && productWithOfferQuanity != null)
{
for (int i = 0; i < productWithOfferQuanity.Quantity; i++)
{
if (i % 2 == 0)
{
CalculateDiscountedPrice(obj.OfferForThisProduct.DiscountAmount, ref obj);
}
}
}
break;
default:
break;
}
}
public BasketModel UpdateBasket(UnverifiedBasket basket)
{
var newBasket = new BasketModel();
if (basket.ID == Guid.Empty)
{
newBasket.ID = Guid.NewGuid();
}
else
{
newBasket.ID = basket.ID;
}
var newLines = new List <VerifiedBasketLine>();
if (basket.Lines?.Length > 0)
{
foreach (var basketLine in basket.Lines)
{
var cheese = this._cheeseCache.Read(basketLine.ProductID);
if (cheese != null)
{
var line = new VerifiedBasketLine();
line.Grams = basketLine.Grams;
line.Name = cheese.Name;
line.RowNo = basketLine.RowNo;
line.Price = Math.Round((basketLine.Grams * cheese.PricePerKG) / 1000, 2, MidpointRounding.AwayFromZero);
line.ProductID = cheese.ID;
newLines.Add(line);
}
}
}
newBasket.Lines = newLines.ToArray();
return(newBasket);
}
public BasketModel CalculatePriceWithDiscounts(BasketEntity basket, IEnumerable <DiscountEntity> discounts)
{
var basketModel = new BasketModel();
foreach (var discount in discounts)
{
var handler = _handlers.SingleOrDefault(x => x.CanHandle(discount));
foreach (var record in basket.Records)
{
if (handler != null && handler.IsApplicable(record, discount))
{
basketModel.Records.Add(handler.Apply(record, discount));
}
else
{
basketModel.Records.Add(new BasketRecordModel(record.Count,
new ProductModel(record.Product.Price)));
}
}
}
return(basketModel);
}
/// <summary>
/// This method updates the quantity of an existing item in basket and re-calculates sub-total
/// </summary>
/// <param name="clientId">Client ID</param>
/// <param name="basketId">Basket ID</param>
/// <param name="itemId">Item ID of basket item</param>
/// <param name="quantity">Quantity of item</param>
/// <returns>True if update item quantity was successful otherwise false</returns>
public bool UpdateBasketItemQuantity(string clientId, string basketId, string itemId, int quantity)
{
bool isUpdated = false;
if (quantity > 0)
{
if (Config.BasketData.Exists(x => x.Client.Id == clientId && x.Id == basketId))
{
BasketModel basketRepModel = Config.BasketData.Find(x => x.Client.Id == clientId && x.Id == basketId);
BasketItemModel basketItemModel = basketRepModel.BasketItems.Find(x => x.Id == itemId);
if (basketItemModel != null)
{
basketItemModel.Quantity = quantity;
//Calculate the new sub-total for this item
basketItemModel.SubTotal = CalculateSubTotal(basketItemModel.UnitPrice, basketItemModel.Quantity, basketItemModel.Discount);
isUpdated = true;
}
}
}
return(isUpdated);
}
public async Task <IActionResult> ChangeCount(BasketModel model)
{
if (!HttpContext.Session.Keys.Contains("basket"))
{
return(RedirectToAction("Index", "Home"));
}
if (model.Count > 65535 || model.Count < 0 || !await db.HasQuantity(model.Id, model.Count))
{
return(RedirectToAction("Error",
new ErrorViewModel()
{
ActionName = "Basket",
RequestInfo = "This count not available!"
}));
}
var basket = HttpContext.Session.Get("basket");
basket.ChangeCount(model.Id, (byte)model.Count);
HttpContext.Session.Set("basket", basket);
return(RedirectToAction("Basket"));
}
/// <summary>
/// This method adds a new item into the basket
/// </summary>
/// <param name="clientId">Client ID</param>
/// <param name="basketId">Basket ID</param>
/// <param name="basketItemModel">Basket items model for item being added</param>
/// <returns>True if add item was successful otherwise false</returns>
public bool AddBasketItem(string clientId, string basketId, BasketItemModel basketItemModel)
{
bool isAdded = false;
//Check if all mandatory fields are present, unit price of item is not less than 0 and quantity is more than 1
if (String.IsNullOrEmpty(basketItemModel.Id) || String.IsNullOrEmpty(basketItemModel.Name) || basketItemModel.UnitPrice < 0 ||
basketItemModel.Quantity < 1)
{
isAdded = false;
}
else
{
if (Config.BasketData.Exists(x => x.Client.Id == clientId && x.Id == basketId))
{
BasketModel basketRepModel = Config.BasketData.Find(x => x.Client.Id == clientId && x.Id == basketId);
//This maybe the first items being added, therefore initialise the items collection here
if (basketRepModel.BasketItems == null)
{
basketRepModel.BasketItems = new List <BasketItemModel>();
}
//If the item already exists, call the UpdateItemQuantity API not this method
if (basketRepModel.BasketItems.Exists(x => x.Id == basketItemModel.Id))
{
isAdded = false;
}
else
{
//Calculate the sub-total price of this item based on unit price and quantity
basketItemModel.SubTotal = CalculateSubTotal(basketItemModel.UnitPrice, basketItemModel.Quantity, basketItemModel.Discount);
basketRepModel.BasketItems.Add(basketItemModel);
isAdded = true;
}
}
}
return(isAdded);
}
public void BindProduct_ShouldReturnTrue_WhenBindToBasket()
{
//Arrange
var basketId = Guid.NewGuid();
var basketDto = new BasketModel
{
Id = basketId
};
BasketOperations.BasketList.Add(basketDto);
var categoryId = Guid.NewGuid();
var categoryTitle = "Technology";
var categoryDto = new CategoryModel
{
Id = categoryId,
Title = categoryTitle
};
var productId = Guid.NewGuid();
var productTitle = "Mobile Phone";
var productDto = new ProductModel
{
Id = productId,
Title = productTitle,
Category = categoryDto,
Price = 4900
};
var amount = 1;
//Act
var result = _basketOperations.BindProduct(basketDto.Id, productDto, amount);
//Assert
Assert.True(result);
}
public List <BasketItemViewModel> GetBasketItems(HttpContextBase httpContext)
{
BasketModel basket = GetBasket(httpContext, false);
if (basket != null)
{
var results = (from b in basket.BasketItems
join p in productContext.Collection() on b.ProductId equals p.Id
select new BasketItemViewModel()
{
Id = b.Id,
Quantity = b.Quantity,
ProductName = p.Name,
Price = p.Price,
Image = p.Image
}
).ToList();
return(results);
}
else
{
return(new List <BasketItemViewModel>());
}
}
public void AddToBasket(HttpContextBase httpContext, string productId)
{
BasketModel basket = GetBasket(httpContext, true);
BasketItemModel item = basket.BasketItems.FirstOrDefault(i => i.ProductId == productId);
if (item == null)
{
item = new BasketItemModel
{
BasketId = basket.Id,
ProductId = productId,
Quantity = 1
};
basket.BasketItems.Add(item);
}
else
{
item.Quantity += 1;
}
basketContext.Commit();
}
public void GetTotalPrice_WithValidBasket_ReturnsPrice()
{
// Arrange
var basketId = "some-basketId";
var basket = new BasketModel
{
Items = new List <BasketItemModel>
{
new BasketItemModel {
ItemId = "", Quantity = 1, UnitPrice = 1
}
}
};
this._storageServiceMock.Setup(x => x.Get <BasketModel>(basketId)).Returns(basket);
this._basketPricingServiceMock.Setup(x => x.CalculateBasketTotalPrice(It.IsAny <BasketModel>())).Returns(3);
// Act
var result = this._subject.GetTotalPrice(basketId);
// Assert
Assert.AreEqual(3, result, "The basket total price is incorrect");
}
public ActionResult LogOn(LogOnModel model)
{
string returnUrl = model.ReturnUrl;
if (ModelState.IsValid)
{
using (ClothesShopEntities entities = new ClothesShopEntities())
{
ClothesShop.User user = entities.Users.Where(x => x.Username == model.UserName && x.Password == model.Password).FirstOrDefault();
if (user != null)
{
Session["Username"] = model.UserName;
Session["UserID"] = user.ID;
Session["IsAuthenticated"] = true;
Session["IsAdmin"] = user.IsAdmin;
Session["Basket"] = new BasketModel();
if (Url.IsLocalUrl(returnUrl) && returnUrl.Length > 1 && returnUrl.StartsWith("/")
&& !returnUrl.StartsWith("//") && !returnUrl.StartsWith("/\\"))
{
return Redirect(returnUrl);
}
else
{
return RedirectToAction("Index", "Home");
}
}
else
{
ModelState.AddModelError("", "The user name or password provided is incorrect.");
}
}
}
// If we got this far, something failed, redisplay form
return View(model);
}
public async Task <ResponseStructure> FreeUpCart(Microsoft.AspNetCore.Http.HttpRequest httpRequest, Microsoft.AspNetCore.Http.HttpResponse httpResponse)
{
StringValues data;
BasketModel basket = new BasketModel();
string cookie;
if (httpRequest.Cookies.TryGetValue("Cart", out cookie))
{
if (cookie != null)
{
httpResponse.Cookies.Delete("Cart");
string token = Barayand.Common.Services.CryptoJsService.EncryptStringToAES(JsonConvert.SerializeObject(basket));
httpResponse.Cookies.Append("Cart", token);
}
}
return(ResponseModel.Success("Cart free."));
}
public static BasketModel UpdateBasket(string id, BasketModel basket)
{
BasketSession[id] = basket;
return(basket);
}
public void SaveBasket(BasketModel basket)
{
HttpContext.Session.SetString("basket", JsonConvert.SerializeObject(basket));
}
/// <summary>
/// Initializes a new instance of the <see cref="Basket"/> class.
/// </summary>
public Basket()
{
_basket = new BasketModel();
_currentDiscounts = new CurrentDiscounts(_basket);
}
public ActionResult OrderDetails(int id)
{
using (ClothesShopEntities entity = new ClothesShopEntities())
{
BasketModel model = new BasketModel();
Order order = entity.Orders.Where(o => o.ID == id).FirstOrDefault();
if (order != null)
{
model.AddRange(order.OrderedProducts.Select(op => new BasketItem(new ProductModel(op.Product), op.Quantity, op.Size)));
}
return View(model);
}
}