public IActionResult Create(Guid productId, [FromBody] ProductOptionViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = _productRepository.GetSingle(productId);
if (product == null)
{
return(NotFound());
}
var newOption = _mapper.Map <ProductOptionViewModel, ProductOption>(model);
newOption.ProductId = productId;
newOption.Product = product;
_productOptionRepository.Add(newOption);
try
{
_productOptionRepository.Commit();
}
catch (DbUpdateException e)
{
_logger.LogCritical(e.Message);
throw e;
}
var newModel = _mapper.Map <ProductOption, ProductOptionViewModel>(newOption);
return(CreatedAtRoute("GetOption", new { productId = productId, id = newModel.Id }, newModel));
}
private void btnRemoveItem_Click(object sender, RoutedEventArgs e)
{
if (dgBeverages.SelectedItem != null)
{
ProductViewModel selected = dgBeverages.SelectedItem as ProductViewModel;
if (selected != null)
{
if (OrderItems.Any(i => i.Id == selected.AddedTo))
{
ProductViewModel itemProductWasAddedTo = OrderItems.Where(i => i.Id == selected.AddedTo).Single();
ProductOptionViewModel addon = itemProductWasAddedTo.AddOnList.Where(a => a.Id == selected.Id).Single();
itemProductWasAddedTo.AddOnList.Remove(addon);
}
if (OrderItems.Any(i => i.AddedTo == selected.Id))
{
var addOnsToRemovedProuduct = OrderItems.Where(i => i.AddedTo == selected.Id);
List <ProductViewModel> toRemove = new List <ProductViewModel>();
foreach (var addon in addOnsToRemovedProuduct)
{
toRemove.Add(addon);
}
foreach (var item in toRemove)
{
OrderItems.Remove(item);
}
}
OrderItems.Remove(selected);
dgBeverages.ItemsSource = OrderItems;
}
}
}
public IActionResult Update(Guid productId, Guid id, [FromBody] ProductOptionViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var options = _productOptionRepository.GetMultiple(s => s.ProductId == productId);
if (options == null || !options.Any())
{
return(NotFound());
}
var option = options.Where(p => p.Id == id).First();
var updatedOption = _mapper.Map <ProductOptionViewModel, ProductOption>(model, option);
option.ProductId = productId;
_productOptionRepository.Update(updatedOption);
try
{
_productOptionRepository.Commit();
}
catch (DbUpdateException e)
{
_logger.LogCritical(e.Message);
throw e;
}
return(new NoContentResult());
}
public static ProductOption ToEntity(this ProductOptionViewModel viewmodel)
{
return(new ProductOption
{
Id = new Guid(viewmodel.Id),
OptionName = viewmodel.OptionName,
ProductId = new Guid(viewmodel.ProductId),
});
}
public async Task <IHttpActionResult> UpdateOption(Guid productId, Guid id, [FromBody] ProductOptionViewModel optionViewModel)
{
var option = ToModel <ProductOptionViewModel, ProductOption>(optionViewModel);
option.ProductId = productId;
var result = await _unitOfWork.ProductOptionRepository.UpdateAsync(option, id);
var viewModel = ToModel <ProductOption, ProductOptionViewModel>(result);
return(HttpResult(viewModel));
}
private bool CheckStockQuantitiesForProductOption(ProductOptionViewModel product, double unit)
{
var db = DbManager.GetInstance();
string message = string.Empty;
if (!db.IsQuantityInStock(stockIdOfShop, product.Id, unit))
{
MessageBox.Show("Not enough quantity in stock for " + ShopGlobals.LocalProductRange.Products.Where(p => p.Id == product.Id).FirstOrDefault().Name + " ");
return(false);
}
return(true);
}
private void GetProductAdons()
{
var flavourings = _AllProducts.Where(p => p.Category.Equals(ProductCategory.flavouring));
foreach (var item in flavourings)
{
ProductOptionViewModel vm = new ProductOptionViewModel();
vm.Id = item.Id;
vm.Name = item.Name;
_ProductAddOns.Add(vm);
}
}
public ActionResult UpdateProductOption(ProductOptionViewModel model)
{
try
{
var option = model.ToEntity();
GenericFactory.Business.UpdateProductOption(option);
return(Json(""));
}
catch (Exception ex)
{
var msg = ex.Message;
}
return(Json(null));
}
public HttpResponseMessage UpdateOption(HttpRequestMessage request, Guid id, ProductOptionViewModel viewModel)
{
return(CreateHttpResponse(request, () =>
{
if (viewModel == null || !ModelState.IsValid)
{
request.CreateResponse(HttpStatusCode.BadRequest, "Invalid Parameters");
}
this._productOptionService.UpdateOption(id, Mapper.Map <ProductOption>(viewModel));
return request.CreateResponse(HttpStatusCode.OK);
}));
}
private void cbMilkOptions_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ComboBox cb = sender as ComboBox;
ProductOptionViewModel selected = cb.SelectedItem as ProductOptionViewModel;
ProductViewModel rowItem = dgBeverages.SelectedItem as ProductViewModel;
double unit = rowItem.Ingredients.MilkTypeIngredients.StockUnit;
if (CheckStockQuantitiesForProductOption(selected, unit * rowItem.Unit))
{
rowItem.Ingredients.MilkTypeIngredients.SelectedOption = selected;
dgBeverages.ItemsSource = null;
dgBeverages.ItemsSource = OrderItems;
}
}
public JsonResult CreateProductOption(ProductOptionViewModel model)
{
try
{
model.Id = Guid.NewGuid().ToString();
var option = model.ToEntity();
GenericFactory.Business.CreateProductOption(option);
return(Json(""));
}
catch (Exception ex)
{
var msg = ex.Message;
}
return(Json(null));
}
/// <summary>
///
/// </summary>
/// <param name="OptionId">Option Id</param>
/// <returns></returns>
public ActionResult EditOption(int?OptionId)
{
if (OptionId == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
var option = db.Product_Options.Find(OptionId);
if (option == null)
{
return(HttpNotFound());
}
var viewModel = new ProductOptionViewModel
{
id = option.Id,
description = option.Description,
details = option.Product_Options_Details.ToDictionary(o => o.Name, o => o.Value),
imageFiles = option.Files.Select(o => o.Id).ToArray(),
name = option.Name,
previewImage = option.PreviewImage != null ? option.PreviewImage.FullFileName : string.Empty,
previewImageId = option.PreviewImageId,
productId = option.ProductId,
productName = option.Product.Name,
status = option.Status,
variants = new Dictionary <string, int[]>()
};
foreach (var item in productVariantTypes)
{
var variants = new List <Product_Variant>();
foreach (var variant in option.Product_Variants)
{
if (variant.VariantType == item)
{
variants.Add(variant);
}
}
viewModel.variants.Add(item.ToString(), variants.Select(o => o.Id).ToArray());
}
var variantCategories = db.Categories.Where(o => o.CategoryTypeId == (int)CategoryTypes.ProductVariant);
ViewBag.VariantCategories = variantCategories;
return(View(viewModel));
}
public async Task InitializeAsync()
{
var product = new ProductViewModel
{
Id = Guid.NewGuid(),
Name = "Test Product",
Price = 1000,
DeliveryPrice = 16
};
_product = await PostAsync(product, "/products");
_productOption = new ProductOptionViewModel
{
Id = Guid.NewGuid(),
Name = ProductOptionName,
Description = "Some description"
};
}
private void bntAddOrderItem_Click(object sender, RoutedEventArgs e)
{
ProductRangeItem selected = cbProducts.SelectedItem as ProductRangeItem;
ProductViewModel vmSelected = ProductRangeItemToViewModel(selected);
if (vmSelected.Ingredients != null && vmSelected.Ingredients.MilkTypeIngredients != null && vmSelected.Ingredients.MilkTypeIngredients.Options != null)
{
ProductOptionViewModel defaultMilkOption = vmSelected.Ingredients.MilkTypeIngredients.Options.ElementAt(0);
vmSelected.Ingredients.MilkTypeIngredients.SelectedOption = defaultMilkOption;
if (!CheckStockQuantitiesForProductOption(defaultMilkOption, vmSelected.Ingredients.MilkTypeIngredients.StockUnit))
{
if (vmSelected.Ingredients.MilkTypeIngredients.Options.Count() > 1)
{
bool foundAvailableMilkOption = false;
int counter = 1;
while (!foundAvailableMilkOption && counter < vmSelected.Ingredients.MilkTypeIngredients.Options.Count())
{
ProductOptionViewModel milkOption = vmSelected.Ingredients.MilkTypeIngredients.Options.ElementAt(counter);
if (CheckStockQuantitiesForProductOption(milkOption, vmSelected.Ingredients.MilkTypeIngredients.StockUnit))
{
vmSelected.Ingredients.MilkTypeIngredients.SelectedOption = milkOption;
foundAvailableMilkOption = true;
MessageBox.Show("Product cannot be served with the default milk option: " + defaultMilkOption.Name);
}
counter++;
}
}
}
}
vmSelected.Unit = 1;
if (CheckStockQuantitiesForProduct(vmSelected))
{
_OrderItems.Add(vmSelected);
dgBeverages.ItemsSource = OrderItems;
}
}
private void cbExtraOptions_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
ComboBox cb = sender as ComboBox;
ProductOptionViewModel selected = cb.SelectedItem as ProductOptionViewModel;
ProductViewModel rowItem = dgBeverages.SelectedItem as ProductViewModel;
if (CheckStockQuantitiesForProductOption(selected, 1))
{
if (rowItem.AddOnList == null)
{
rowItem.AddOnList = new List <ProductOptionViewModel>();
}
if (!rowItem.AddOnList.Contains(selected))
{
rowItem.AddOnList.Add(selected);
ProductViewModel addOn = ProductRangeItemToViewModel(_AllProducts.Where(p => p.Id == selected.Id).Single());
addOn.AddedTo = rowItem.Id;
addOn.Unit = 1;
OrderItems.Add(addOn);
dgBeverages.ItemsSource = OrderItems;
}
}
}
public ActionResult CreateOption(ProductOptionViewModel viewModel)
{
if (ModelState.IsValid)
{
var model = new Product_Option
{
Name = viewModel.name,
Description = viewModel.description,
ProductId = viewModel.productId,
PreviewImageId = viewModel.previewImageId,
Status = viewModel.status,
Files = new List <File>(),
CreateUserId = User.Identity.GetUserId(),
CreateTime = DateTime.Now
};
if (viewModel.variants != null)
{
foreach (var variant in viewModel.variants)
{
foreach (var variantId in variant.Value)
{
var variantModel = db.Product_Variants.Find(variantId);
if (variantModel != null)
{
variantModel.Product_Options.Add(model);
}
}
}
}
if (viewModel.imageFiles != null)
{
foreach (var file in viewModel.imageFiles)
{
var fileModel = db.Files.Find(file);
if (fileModel != null)
{
model.Files.Add(fileModel);
}
}
}
if (viewModel.details != null)
{
foreach (var pair in viewModel.details)
{
if (pair.Key != string.Empty && pair.Value != string.Empty)
{
var detailModel = new Product_Options_Details
{
Name = pair.Key,
Value = pair.Value,
};
db.Product_Options_Details.Add(detailModel);
model.Product_Options_Details.Add(detailModel);
}
}
}
db.Product_Options.Add(model);
db.SaveChanges();
return(RedirectToAction("CreateOption", new { productId = model.ProductId, success = true, successObjectName = model.Name }));
}
var variantCategories = db.Categories.Where(o => o.CategoryTypeId == (int)CategoryTypes.ProductVariant);
ViewBag.VariantCategories = variantCategories;
var product = db.Products.Find(viewModel.productId);
var options = product.Product_Options;
ViewBag.Options = options;
return(View(viewModel));
}
private ProductViewModel ProductRangeItemToViewModel(ProductRangeItem item)
{
ProductViewModel vm = new ProductViewModel();
vm.Id = item.Id;
vm.Name = item.Name;
vm.Price = item.Price;
vm.Category = item.Category;
vm.Ingredients = new IngredientsViewModel();
if (item.Category.ToString().Contains("beverage"))
{
vm.Ingredients.ExtraIngredients = _ProductAddOns;
}
if (item.Ingredients != null)
{
if (item.Ingredients.BaseIngredients != null && item.Ingredients.BaseIngredients.Count() > 0)
{
List <BaseIngredientViewModel> vmBaseIngredientList = new List <BaseIngredientViewModel>();
foreach (var i in item.Ingredients.BaseIngredients)
{
BaseIngredientViewModel vmBaseIngredient = new BaseIngredientViewModel()
{
Id = i.Id,
StockUnit = i.StockUnit,
Name = _AllProducts.Where(p => p.Id == i.Id).Select(p => p.Name).Single(),
};
vmBaseIngredientList.Add(vmBaseIngredient);
}
vm.Ingredients.BaseIngredients = vmBaseIngredientList;
}
if (item.Ingredients.MilkTypeIngredients != null)
{
MilkTypeIngredientsViewModel vmMilkType = new MilkTypeIngredientsViewModel()
{
StockUnit = item.Ingredients.MilkTypeIngredients.StockUnit,
};
vm.Ingredients.MilkTypeIngredients = vmMilkType;
List <ProductOptionViewModel> vmOptionList = new List <ProductOptionViewModel>();
foreach (var id in item.Ingredients.MilkTypeIngredients.Options)
{
ProductOptionViewModel vmOption = new ProductOptionViewModel()
{
Id = id,
Name = _AllProducts.Where(p => p.Id == id).Select(p => p.Name).Single(),
};
vmOptionList.Add(vmOption);
}
vm.Ingredients.MilkTypeIngredients.Options = vmOptionList;
}
if (item.Ingredients.ExtraIngredients != null && item.Ingredients.ExtraIngredients.Count() > 0)
{
List <ProductOptionViewModel> vmOptionList = new List <ProductOptionViewModel>();
foreach (var id in item.Ingredients.ExtraIngredients)
{
ProductOptionViewModel vmOption = new ProductOptionViewModel()
{
Id = id,
Name = _AllProducts.Where(p => p.Id == id).Select(p => p.Name).Single(),
};
vmOptionList.Add(vmOption);
vmOptionList.AddRange(vm.Ingredients.ExtraIngredients);
}
vm.Ingredients.ExtraIngredients = vmOptionList;
}
}
return(vm);
}
public ActionResult EditOption(ProductOptionViewModel viewModel)
{
if (ModelState.IsValid)
{
var model = db.Product_Options.Find(viewModel.id);
model.Name = viewModel.name;
model.Description = viewModel.description;
model.ProductId = viewModel.productId;
model.PreviewImageId = viewModel.previewImageId;
model.Status = viewModel.status;
model.Product_Variants.Clear();
if (viewModel.variants != null)
{
foreach (var variant in viewModel.variants)
{
foreach (var variantId in variant.Value)
{
var variantModel = db.Product_Variants.Find(variantId);
if (variantModel != null)
{
variantModel.Product_Options.Add(model);
}
}
}
}
model.Files.Clear();
if (viewModel.imageFiles != null)
{
foreach (var file in viewModel.imageFiles)
{
var fileModel = db.Files.Find(file);
if (fileModel != null)
{
model.Files.Add(fileModel);
}
}
}
model.Product_Options_Details.Clear();
if (viewModel.details != null)
{
foreach (var pair in viewModel.details)
{
if (pair.Key != string.Empty && pair.Value != string.Empty)
{
var detailModel = new Product_Options_Details
{
Name = pair.Key,
Value = pair.Value,
};
db.Product_Options_Details.Add(detailModel);
model.Product_Options_Details.Add(detailModel);
}
}
}
db.Entry(model).State = System.Data.Entity.EntityState.Modified;
if (db.SaveChanges() > 0)
{
return(RedirectToAction("CreateOption", new { productId = model.ProductId }));
}
}
var variantCategories = db.Categories.Where(o => o.CategoryTypeId == (int)CategoryTypes.ProductVariant);
ViewBag.VariantCategories = variantCategories;
return(View(viewModel));
}
public static ProductOptionViewModel GetProductById(int id)
{
ProductOptionViewModel productAtrributeViewModel = new ProductOptionViewModel();
List<ProductAtrributeOptionsViewModel> viewModel = new List<ProductAtrributeOptionsViewModel>();
using (EcommerceEntities entities = new EcommerceEntities())
{
//ResponseViewModel<ProductAtrributeOptionsViewModel> response = new ResponseViewModel<ProductAtrributeOptionsViewModel>();
List<Product_Attribute> options = new List<Product_Attribute>();
List<ProductAttribute> attributes = new List<ProductAttribute>();
//List<ProductAttributeOption> options = new List<ProductAttributeOption>();
GetProductById_Result result = entities.GetProductById(id).FirstOrDefault();//get api of product
Product product = new Product();
product.Name = result.Name;
product.ID = result.ID;
product.Price = result.Price;
product.ProductCateogoryID = result.CategoryId;
product.ProductSubCategoryID = result.SubCategoryID;
product.Image = result.Image;
product.Description = result.Description;
product.Discount = result.Discount;
product.Quentity = result.Quentity;
options = entities.Product_Attribute.Where(entry => entry.ProductID == id).ToList();
//attributes = entities.ProductAttributes.Where(entry => entry. == product.ProductSubCategoryID).ToList();
if (options != null)
{
foreach (var option in options)
{
ProductAtrributeOptionsViewModel attributeOptionViewModel = new ProductAtrributeOptionsViewModel();
ProductAtrributeOptionsViewModel attributeOptionViewModelObj = new ProductAtrributeOptionsViewModel();
List<OptionList> optionsList = new List<OptionList>();
ProductAttributeOption optionDb = new ProductAttributeOption();
ProductAttribute productAttributeDb = new ProductAttribute();
optionDb = entities.ProductAttributeOptions.Where(entry => entry.ID == option.OptionID).FirstOrDefault();
productAttributeDb = entities.ProductAttributes.Where(entry => entry.ID == optionDb.ProductAtrributeID).FirstOrDefault();
attributeOptionViewModel.attributeName = productAttributeDb.Name;
attributeOptionViewModel.attributeId = Convert.ToInt32(productAttributeDb.ID);
if(viewModel.Any(entry => entry.attributeId == attributeOptionViewModel.attributeId))
{
attributeOptionViewModelObj = viewModel.Where(entry => entry.attributeId == attributeOptionViewModel.attributeId).FirstOrDefault();
if (attributeOptionViewModelObj != null)
{
OptionList optionViewModel = new OptionList();
optionViewModel.optionName = optionDb.Value;
optionViewModel.optionId = Convert.ToInt32(optionDb.ID);
attributeOptionViewModel.optionList = optionsList;
attributeOptionViewModelObj.optionList.Add(optionViewModel);
}
}
else
{
OptionList optionViewModel = new OptionList();
optionViewModel.optionName = optionDb.Value;
optionViewModel.optionId = Convert.ToInt32(optionDb.ID);
optionsList.Add(optionViewModel);
attributeOptionViewModel.optionList = optionsList;
viewModel.Add(attributeOptionViewModel);
}
}
}
productAtrributeViewModel.product = product;
productAtrributeViewModel.ViewModel = viewModel;
}
return productAtrributeViewModel;
}
