public void ManyToManyUpdateTest()
{
using (EasySession easySession = new EasySession())
{
///[Test Update] - many-to-many relationship
ProductModelIllustration productModelIllustration = new ProductModelIllustration();
int resultCount = productModelIllustration.Count(easySession);
Assert.AreEqual(5, resultCount);
ProductModel productModel = new ProductModel();
resultCount = productModel.Count(easySession);
Assert.AreEqual(129, resultCount);
productModel.ProductModelID = 47;
ProductModel resultList = productModel.Find(easySession, EasyLoad.Simple);
//resultList.Illustration.RemoveAt(0);
bool result = resultList.Update(easySession);
resultCount = resultList.Count(easySession);
Assert.AreEqual(129, resultCount);
resultCount = productModelIllustration.Count(easySession);
Assert.AreEqual(5, resultCount);
}
}
public ViewResult MainViewResult()
{
var viewResult = new ViewResult();
viewResult.ViewName = "Index";
var userProducts = new ProductModel(Domain.User.Products);
userProducts.Refresh();
var userAccount = new AccountModel(Domain.User.Account);
userAccount.Refresh();
var vmProducts = new ProductModel(Domain.VM.Products);
vmProducts.Refresh();
var vmBankAccount = new AccountModel(Domain.VM.BankAccount);
vmBankAccount.Refresh();
viewResult.ViewBag.UserProducts = userProducts;
viewResult.ViewBag.UserAccount = userAccount;
viewResult.ViewBag.VMProducts = vmProducts;
viewResult.ViewBag.VMBankAccount = vmBankAccount;
viewResult.ViewBag.VMUserAccount = Domain.VM.UserAccount;
return viewResult;
}
public GridResponseModel<ProductModel> Get(GridRequestModel gridRequestModel, ProductModel searchModel)
{
var query = _unitOfWork.ProductRepository.Queryable;
if (searchModel != null)
{
if (searchModel.ProductTypeId > 0)
query = query.Where(p => p.ProductType.Id == searchModel.ProductTypeId);
if (searchModel.SupplierId > 0)
query = query.Where(p => p.Supplier != null && p.Supplier.Id == searchModel.SupplierId);
if (!string.IsNullOrWhiteSpace(searchModel.Name))
query = query.Where(p => p.Name.Contains(searchModel.Name));
}
switch (gridRequestModel.Sidx)
{
default:
case "Name":
query = query.OrderBy(p => p.Name, gridRequestModel.IsSortAsending);
break;
}
var dbModel = query.ToPagingResult(gridRequestModel);
var model = dbModel.Rows.Select(m => Mapper.Map<ProductModel>(m)).ToArray();
var gridData = new GridResponseModel<ProductModel>(gridRequestModel, dbModel.RowCount, model);
return gridData;
}
public void VmShouldUseResourceNameEditEntity()
{
var model = new ProductModel();
var viewModel = GetViewModel<ProductEditorViewModel>();
viewModel.InitializeEntity(model, false);
Assert.AreEqual(viewModel.DisplayName, UiResources.ProductEditDisplayName);
}
//GET api/products/{productId}
public HttpResponseMessage GetProduct(int productId, [ValueProvider(typeof(HeaderValueProviderFactory<string>))]string sessionKey)
{
var responseMsg = this.PerformOperationAndHandleExceptions<HttpResponseMessage>(
() =>
{
using (var context = new StoreContext())
{
this.ValidateSessionKey(sessionKey);
var product = context.Products.Include("Category").FirstOrDefault(p => p.Id == productId);
if (product == null)
{
throw new ArgumentException("Product not found");
}
var resultProductModel = new ProductModel
{
Id = product.Id,
Name = product.Name,
Price = product.Price,
CategoryName = product.Category.Name,
CategoryId = product.Category.Id,
Description = product.Description,
ImageSource = product.ImageSource,
Quantity = product.Quantity
};
var response = this.Request.CreateResponse(HttpStatusCode.OK,
resultProductModel);
return response;
}
});
return responseMsg;
}
public ActionResult Create(ProductModel model)
{
bool isNotExist = _productRepo.FindDuplicateByName(model.Name);
if (isNotExist)
{
Categories category = _categoryRepo.Get(Int32.Parse(model.Category));
Manufacturers manufacturer = _manufacturersRepo.Get(Int32.Parse(model.Manufacturer));
var product = new Products(model.Name, model.Description,
Convert.ToDecimal(model.Price, CultureInfo.InvariantCulture), category, manufacturer,
Int32.Parse(model.Quantity), model.IsFeatured, model.IsRecent, model.IsBestSeller, model.ShortDescription);
try
{
_productRepo.Save(product);
TempData["success"] = "Pomyślnie dodano nowy towar.";
return RedirectToAction("index");
}
catch (Exception)
{
TempData["error"] = "Wystąpił problem z połączeniem do bazy danych.";
return RedirectToAction("Create");
}
}
TempData["error"] = "Towar o podanej nazwie już istnieje";
return RedirectToAction("Create");
}
private void FillPage()
{
//Get selected product's data
if (!String.IsNullOrWhiteSpace(Request.QueryString["id"]))
{
int id = Convert.ToInt32(Request.QueryString["id"]);
ProductModel productModel = new ProductModel();
Product product = productModel.GetProduct(id);
ZHUW15sqlserver1Entities db = new ZHUW15sqlserver1Entities();
//Fill Page with data
lblColor.Text = " " + product.Color;
lblPrice.Text = " $" + product.Price;
lblTitle.Text = product.Name;
lblDescription.Text = product.Description;
lblProductNum.Text = "Product Number: "+ id.ToString();
imgProdcut.ImageUrl = "~/Image/Products/" + product.Image;
//Retrieve supplier
int supplierId = product.SupplierID;
Supplier supplier = db.Suppliers.Find(supplierId);
lblSupplier.Text = "By " + supplier.Name;
//Fille amount dropdown list with numbers 1-30;
int[] quantity = Enumerable.Range(1, 30).ToArray();
ddlQuantity.DataSource = quantity;
ddlQuantity.AppendDataBoundItems = true;
ddlQuantity.DataBind();
}
}
public List<ProductModel> getProduct(IEnumerable<Product> data)
{
var list = new List<ProductModel>();
if (data != null)
{
foreach (var model in data)
{
var prod = new ProductModel();
if (model != null)
{
prod.CategoryId = model.CategoryId;
prod.Discontinued = model.Discontinued;
prod.Name = model.Name;
prod.ProductCategory = getCategory(model.ProductCategory);
prod.ProductId = model.ProductId;
prod.ProductSupplier = getSupplier(model.ProductSupplier);
prod.QuantityPerUnit = model.QuantityPerUnit;
prod.ReorderLevel = model.ReorderLevel;
prod.SupplierId = model.SupplierId;
prod.UnitPrice = model.UnitPrice;
prod.UnitsInStock = model.UnitsInStock;
prod.UnitsOnOrder = model.UnitsOnOrder;
}
list.Add(prod);
}
}
return list;
}
public void Create(ProductModel model)
{
var dbModel = Mapper.Map<Product>(model);
dbModel.ProductType = _unitOfWork.ProductTypeRepository.Get(model.ProductTypeId);
dbModel.Supplier = _unitOfWork.SupplierRepository.Get(model.SupplierId);
_unitOfWork.ProductRepository.Create(dbModel);
}
public ActionResult SaveProduct(ProductModel model)
{
if(model != null)
{
model.SupplierId = 1;
_service.SaveProduct(model);
}
return new HttpStatusCodeResult(201, "Created Successfully");
}
public ActionResult Index(string id)
{
var products = _unitOfWork.ProductRepository.Get().ToList();
var product = _unitOfWork.ProductRepository.GetById(new Guid(id));
if (product == null)
{
return View("Error");
}
var image800x640Paths = product.Image800x640Paths.ToList();
var imageAdditional = GetImageAdditionalModels(image800x640Paths);
var relatedProductIds = _unitOfWork.RelatedProductRepository.Get(i=>i.ProductId==new Guid(id)).Select(r=>r.RelatedProductId);
var relatedProducts = _unitOfWork.ProductRepository.Get(p => relatedProductIds.Contains(p.Id)).ToList();
var relatedProductBlocks = GetRelatedProductBlocks(relatedProducts);
var categoryViewModels = GetCategories(product, products);
var specialProduct = products.First(i => i.Id == new Guid("CD4879A0-C210-4DAA-A6DE-A59E9CC153BF"));
var specialProductViewModel = new SpecialProductViewModel
{
Id = specialProduct.Id.ToString(),
Name = specialProduct.Name,
OldPrice = specialProduct.OldPrice.HasValue ? specialProduct.OldPrice.Value.ToString("C") : string.Empty,
NewPrice = specialProduct.NewPrice.ToString("C"),
RatingImagePath = specialProduct.RatingImagePath,
Image240x192Path = specialProduct.Image240x192Path
};
var productInfo = new ProductInfo
{
Id = product.Id.ToString(),
Name = product.Name,
DefaultImage = image800x640Paths.First(i => i.IsActive).Path,
OldPrice = product.OldPrice.HasValue ? product.OldPrice.Value.ToString("C") : string.Empty,
NewPrice = product.NewPrice.ToString("C"),
ExTax = (product.NewPrice - product.NewPrice*.15m).ToString("C"),
Brand = product.Brand.Name,
BrandId = product.Brand.Id.ToString(),
Description = product.Description,
ImageAdditionals = imageAdditional,
Availability = "In Stock"
};
var productModel = new ProductModel
{
ProductInfo=productInfo,
RelatedProductBlocks = relatedProductBlocks,
RelatedProductCount=relatedProducts.Count,
CategoryViewModels=categoryViewModels,
SpecialProductViewModel=specialProductViewModel
};
return View(productModel);
}
public ActionResult CreateOrUpdate(ProductModel productModel)
{
if (ModelState.IsValid && productModel.IsValid())
{
this.productModelTasks.CreateOrUpdate(productModel);
return this.RedirectToAction(x => x.Index());
}
return View(productModel);
}
public ActionResult Create(ProductModel model)
{
if (this.ModelState.IsValid)
{
_productService.Create(model);
return RedirectToAction("Index");
}
return View(model);
}
//FillPage() method
private void FillPage(int id)
{
ProductModel pModel = new ProductModel();
Product product = pModel.GetProduct(id);
descriptionTextBox.Text = product.Description;
nameTextBox.Text = product.Name;
priceTextBox.Text = product.Price.ToString();
imageDropDownList.SelectedValue = product.Image;
typeDropDownList.SelectedValue = product.Type.ToString();
quantityTextBox.Text = product.Quantity.ToString();
}
public ActionResult AddBook(HttpPostedFileBase file, AddProductViewModel model)
{
Session["Username"] = "******";
var userName = Session["Username"];
var imagePath = CreateMD5(model.Title + DateTime.Now + DateTime.Now.Millisecond + model.Detail) ;
var addViewModel = new ProductModel();
addViewModel.Title = model.Title;
addViewModel.Author = model.Author;
addViewModel.Image = imagePath;
addViewModel.Detail = model.Detail;
addViewModel.Balance = model.Balance;
addViewModel.Isbn = model.Isbn;
addViewModel.Price = model.Price;
addViewModel.CategoryId = model.CategoryId;
addViewModel.CreateBy = userName.ToString();
addViewModel.CreateTime = DateTime.Now;
addViewModel.UpdateBy = "Test Admin";
addViewModel.UpdateTime = DateTime.Now;
addViewModel.IsActive = true;
bool uploadImageIsComplete = true;
if (file != null && file.ContentLength > 0)
try
{
var fileName = imagePath + ".jpg";
var path = Path.Combine(Server.MapPath("~/Content/images/Product/"), fileName);
file.SaveAs(path);
}
catch (Exception ex)
{
uploadImageIsComplete = false;
}
else
{
uploadImageIsComplete = false;
}
if (uploadImageIsComplete)
{
ProductService productService = new ProductService();
if (productService.Save(addViewModel))
{
// return RedirectToRoute("~Success");
}
else
{
// return RedirectToRoute("~Error");
}
}
return RedirectToAction("ManageProductView", "ManageProduct");
}
// PUT api/awbuildversion/5
public void Put(ProductModel value)
{
var GetActionType = Request.Headers.Where(x => x.Key.Equals("ActionType")).FirstOrDefault();
if (GetActionType.Key != null)
{
if (GetActionType.Value.ToList()[0].Equals("DELETE"))
adventureWorks_BC.ProductModelDelete(value);
if (GetActionType.Value.ToList()[0].Equals("UPDATE"))
adventureWorks_BC.ProductModelUpdate(value);
}
}
private void FillPage(int id ){
ProductModel productModel = new ProductModel();
Product product = productModel.GetProduct(id);
txtDescription.Text = product.Description;
txtName.Text = product.Name;
txtPrice.Text = product.Price.ToString();
ddlImage.SelectedValue = product.Image;
ddlType.SelectedValue = product.TypeId.ToString();
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
ProductModel productModel = new ProductModel();
Product product = CreateProduct();
if (!String.IsNullOrWhiteSpace(Request.QueryString["id"]))
{
int id = Convert.ToInt32(Request.QueryString["id"]);
lblResult.Text = productModel.UpdateProduct(id, product);
}
else
{
lblResult.Text = productModel.InsertProduct(product);
}
}
protected void SPTest()
{
using (EasySession easySession = new EasySession())
{
ProductModel productModel = new ProductModel();
int resultCount = productModel.Count(easySession);
Assert.AreEqual(129, resultCount);
ObjectQuery testOQ = new ObjectQuery();
//testOQ.DeleteSP("uspDeleteProductModels", easySession).SetParameterList("list", new int[] { 1, 2, 3 }, typeof(int)).Execute();
resultCount = productModel.Count(easySession);
Assert.AreEqual(126, resultCount);
}
}
public void VmShouldNotBeValidDescriptionIsNull()
{
var model = new ProductModel
{
Name = "test",
Id = Guid.NewGuid(),
Price = 100
};
var viewModel = GetViewModel<ProductEditorViewModel>();
viewModel.InitializeEntity(model, false);
Assert.IsFalse(viewModel.IsValid);
viewModel.Description = "test";
viewModel.ValidateAsync(() => editorViewModel => editorViewModel.Description);
Assert.IsTrue(viewModel.IsValid);
}
public void ManyToManyReadTest()
{
using (EasySession easySession = new EasySession())
{
///[Test Read] - many-to-many relationship
ProductModel productModel = new ProductModel();
//IList resultList = productModel.FindAll(easySession); //, EasyLoad.None
List<ProductModel> resultList = productModel.FindAll(easySession, EasyLoad.Simple);
//ProductModels test = new ProductModels();
//test.d
//ProductModels ProductList = (ProductModels)Convert.ChangeType(resultList, typeof(ProductModels));
Assert.AreEqual(129, resultList.Count);
}
}
private void FillPage(int id)
{
//Get selected product from DB
ProductModel productModel = new ProductModel();
Product product = productModel.GetProduct(id);
//Fill textboxes
txtDescription.Text = product.Description;
txtName.Text = product.Name;
txtPrice.Text = product.Price.ToString();
//Set dropdown list values
ddlImage.SelectedValue = product.Image;
ddlType.SelectedValue = product.TypeId.ToString();
}
protected void QueryTest()
{
using (EasySession easySession = new EasySession())
{
ProductModel productModel = new ProductModel();
int resultCount = productModel.Count(easySession);
Assert.AreEqual(129, resultCount);
ObjectQuery testOQ = new ObjectQuery();
//testOQ.EasyQuery(easySession).From(productModel.GetType()).Where().
//var result = testOQ.DeleteQuery("DELETE FROM Production.ProductModel WHERE ProductModelID IN (:list)", easySession).SetParameterList("list", new int[] { 1, 2, 3 }, typeof(int)).Execute();
resultCount = productModel.Count(easySession);
Assert.AreEqual(126, resultCount);
}
}
private void FillPage()
{
//get a list of all products in DB
ProductModel productModel = new ProductModel();
List<Product> products = productModel.GetAllProducts();
//make sure products exist in database
if (products != null)
{
//create new Pannel with an ImageButton and 2 labels for each Product
foreach (Product product in products)
{
Panel productPanel = new Panel();
ImageButton imageButton = new ImageButton();
Label lblName = new Label();
Label lblPrice = new Label();
//set ChildControls properties
imageButton.ImageUrl = "~/Images/Products/" + product.Image;
imageButton.CssClass = "productImage";
imageButton.PostBackUrl = "~/Pages/Product.aspx?id=" + product.Id;
lblName.Text = product.Name;
lblName.CssClass = "productName";
lblPrice.Text = product.Price + " лв.";
lblPrice.CssClass = "productPrice";
//Add child controls to pannel
productPanel.Controls.Add(imageButton);
productPanel.Controls.Add(new Literal { Text = "<br/>" });
productPanel.Controls.Add(lblName);
productPanel.Controls.Add(new Literal { Text = "<br/>" });
productPanel.Controls.Add(lblPrice);
//add dynamic panels to static parent panel
pnlProducts.Controls.Add(productPanel);
}
}
else
{
//no products found
pnlProducts.Controls.Add(new Literal { Text = "No products found!" });
}
}
private void FillForm(int id)
{
//Get selected product from DB
ProductModel productmodel = new ProductModel();
Product product = productmodel.GetProduct(id);
//Fill textboxes
txtDescription.Text = product.Description;
txtName.Text = product.Name;
txtColor.Text = product.Color;
txtPrice.Text = product.Price.ToString();
//Set dropdpwn list value
ddlImage.SelectedValue = product.Image;
ddlCategory.SelectedValue = product.CategoryID.ToString();
ddlSupplier.SelectedValue = product.SupplierID.ToString();
}
protected void Button1_Click(object sender, EventArgs e)
{
ProductModel productModel = new ProductModel();
Product product = CreateProduct();
//check if the url contains an id parameter
if (!String.IsNullOrWhiteSpace(Request.QueryString["id"]))
{
//ID exits - update existing row
int id = Convert.ToInt32(Request.QueryString["id"]);
lblResult.Text = productModel.UpdateProduct(id, product);
}
else
{
//ID does not exist - create new row
lblResult.Text = productModel.InsertProduct(product);
}
}
public ProductControl(string host, int port, string dbname, string username,
string password, string table_name, ProductParser parser)
{
this.InitializeComponent();
ProductParser newParser = new ProductParser();
dataModel = new ProductModel(
this.gvProducts,
host,
port,
dbname,
username,
password,
"Production.Products",
newParser);
newParser.DataModel = dataModel;
this._initModel();
}
public ProductModel GetProduct(int ProductId)
{
using (var db = new TankshopDbContext())
{
var product = db.Products.Find(ProductId);
var productModel = new ProductModel()
{
CategoryId = product.CategoryId,
CategoryName = product.Category.Name,
Description = product.Description,
ImageUrl = product.ImageUrl,
Price = product.Price,
ProductId = product.ProductId,
ProductName = product.Name,
Stock = product.Stock
};
return productModel;
}
}
private void FillForm(int id)
{
try
{
ProductModel productModel = new ProductModel();
Product product = productModel.GetProduct(id);
txtDescription.Text = product.Description;
txtName.Text = product.Name;
txtPrice.Text = product.Price.ToString();
ddlImage.SelectedValue = product.Image;
ddlType.SelectedValue = product.TypeID.ToString();
}
catch (Exception ex)
{
lblResult.Text = ex.ToString();
}
}
protected void btnSubmit_Click(object sender, EventArgs e)
{
ProductModel productModel = new ProductModel();
Product product = CreateProduct();
if(!String.IsNullOrWhiteSpace(Request.QueryString["id"]))
{
//ID exists then upadte existing row
int id = Convert.ToInt32(Request.QueryString["id"]);
lblResult.Text = productModel.UpdateProduct(id, product);
}
else
{
//ID dose not xist then creat a new row
lblResult.Text = productModel.InsertProduct(product);
}
Response.Redirect("~/Pages/Management/ManageWebsite.aspx", false);
}
public async Task <IActionResult> AddMultipleProducts()
{
var productList = new List <ProductModel>();
var excelFile = Request.Form.Files.FirstOrDefault(x => x.FileName.Contains(".xlsx"));
if (excelFile != null)
{
var package = new ExcelPackage(excelFile.OpenReadStream());
var worksheet = package.Workbook.Worksheets.FirstOrDefault();
for (int i = worksheet.Dimension.Start.Row + 1; i < worksheet.Dimension.End.Row + 1; i++)
{
var row = worksheet.Cells[i, 1, i, 9].ToArray();
if (row != null && row.Length > 0)
{
string PartNumber = row[0].Text;
var existingPart = await _context.Products.FirstOrDefaultAsync(x => x.PartNumber == PartNumber);
if (existingPart == null)
{
string Name = row[1].Text;
string Description = row[2].Value.ToString();
BrandModel Brand = await _context.Brand.FirstOrDefaultAsync(x => x.Name.Replace(" ", "").ToUpper() == row[3].Text.Replace(" ", "").ToUpper());
PartTypeEnum PartType = (PartTypeEnum)Enum.Parse(typeof(PartTypeEnum), row[4].Text);
decimal Price = decimal.Parse(row[5].Text);
string CarMake = row[6].Text;
string CarModel = row[7].Text;
var carFound = await _context.Car.FirstOrDefaultAsync(x => x.Make.Replace(" ", "").Replace("-", "").ToUpper() == CarMake.Replace(" ", "").Replace("-", "").ToUpper() &&
x.Model.Replace(" ", "").Replace("-", "").ToUpper() == CarModel.Replace(" ", "").Replace("-", "").ToUpper());
CarModel Car = null;
if (carFound != null)
{
Car = carFound;
}
else
{
Car = new CarModel
{
Make = CarMake,
Model = CarModel
};
_context.Car.Add(Car);
await _context.SaveChangesAsync();
}
string Years = (string.IsNullOrEmpty(row[8].Text) || row[8].Text.ToUpper() == "ALL") ? null : row[8].Text.ToUpper().Replace(" ", "").Replace("-", " - ").Replace("UP", "Present");
var Product = new ProductModel
{
PartNumber = PartNumber,
Name = Name,
Description = Description,
Brand = Brand,
PartType = PartType,
Price = Price,
Years = Years,
Shipping = await CalculateShippingAsync(Price)
};
CarProduct CarProduct = new CarProduct
{
CarId = Car.CarId,
Car = Car,
ProductId = Product.PartId,
Product = Product
};
Product.CarProducts = new List <CarProduct>();
Product.CarProducts.Add(CarProduct);
Product.DateAdded = DateTime.UtcNow;
productList.Add(Product);
}
}
else
{
i = 999999;
}
}
_context.Products.AddRange(productList);
}
var imagesUploaded = 0;
var allImages = Request.Form.Files.Where(x => !x.FileName.Contains(".xlsx"));
var productNumbers = allImages.Select(x => x.FileName.Split('(')[0]).Distinct();
var products = new List <ProductModel>();
foreach (var productNumber in productNumbers)
{
var product = await _context.Products.Include(x => x.Images).FirstOrDefaultAsync(x => x.PartNumber.ToUpper() == productNumber.ToUpper());
if (product != null)
{
var newImageList = new List <ImageModel>();
foreach (var image in allImages.Where(x => x.FileName.ToUpper().Contains(product.PartNumber.ToUpper())))
{
newImageList.Add(new ImageModel
{
Name = image.FileName.Split('.')[0],
Description = image.FileName,
Bytes = ConvertToBytes(image)
});
}
product.Images = newImageList;
}
}
await _context.SaveChangesAsync();
TempData["Message"] = $"Successfully added {productList.Count} products to the store. Successfully uploaded {imagesUploaded} images.";
return(RedirectToAction("AddProduct", new { section = "PART" }));
}
public async Task <IActionResult> Update(ProductModel recivedProduct)
{
var result = await _service.UpdateProduct(recivedProduct);
return(Ok(result));
}
public int Update(ProductModel product)
{
throw new NotImplementedException();
}
public JsonResult Edit(ProductModel model)
{
model.UpdatedBy = _context.CurrentAccount.AccountId;
this._productFacade.Edit(model);
return(Json(new { success = true }));
}
public void AddToBasket(ProductModel product)
{
BasketProducts.Add(product);
}
public void SaveSale(SaleModel saleInfo, string cashierId)
{
//TODO : Make this SOLID/DRY/Better
// Start filling in the sale detail models we will save to the database
// Fill in the available information
List <SaleDetailDBModel> details = new List <SaleDetailDBModel>();
decimal taxRate = GetTaxRate();
foreach (SaleDetailModel item in saleInfo.SaleDetails)
{
SaleDetailDBModel detail = new SaleDetailDBModel
{
ProductId = item.ProductId,
Quantity = item.Quantity
};
//Get the information about this product
ProductModel productInfo = _productData.GetProductById(detail.ProductId);
if (productInfo == null)
{
throw new Exception($"The product Id of { detail.ProductId } could not be found in the database.");
}
detail.PurchasePrice = (productInfo.RetailPrice * detail.Quantity);
if (productInfo.IsTaxable)
{
detail.Tax = (detail.PurchasePrice * taxRate);
}
details.Add(detail);
}
// Create the sale model
SaleDBModel sale = new SaleDBModel
{
SubTotal = details.Sum(x => x.PurchasePrice),
Tax = details.Sum(x => x.Tax),
CashierId = cashierId
};
sale.Total = sale.SubTotal + sale.Tax;
try
{
_sql.StartTransaction("TRMData");
// Save the sale model
_sql.SaveDataInTransaction("dbo.spSale_Insert", sale);
// Get the ID from the sale model //we assumed that it has the Id
sale.Id = _sql.LoadDataInTransaction <int, dynamic>("spSale_Lookup", new { sale.CashierId, sale.SaleDate }).FirstOrDefault();
// Finish filling in the sale detail models
foreach (SaleDetailDBModel item in details)
{
item.SaleId = sale.Id;
// Save the sale detail models
_sql.SaveDataInTransaction("dbo.spSaleDetail_Insert", item);
}
_sql.CommitTransaction();
}
catch
{
_sql.RollbackTransaction();
throw;
}
}
public async Task <ActionResult> Edit([Bind(Include = "SKU, ProductName, Description, CoverPath, Price, BrandID")] ProductModel productModel)
{
if (ModelState.IsValid)
{
if (!await(from p in db.Products where p.ProductName.ToLower() == productModel.ProductName.ToLower() && p.BrandID == productModel.BrandID && p.SKU != productModel.SKU select p).AnyAsync())
{
ProductModel editedProduct = await db.Products.FindAsync(productModel.SKU);
string[] pictures = Request.Form.GetValues("ProductPictures") ?? new string[] { };
for (int i = 0; i < pictures.Length; i++)
{
for (int j = i + 1; j < pictures.Length; j++)
{
if (pictures[i].Equals(pictures[j]))
{
pictures[j] = "";
}
}
}
List <ProductPictureModel> ppmLst = new List <ProductPictureModel>();
foreach (string str in pictures)
{
if (!str.Equals(""))
{
ppmLst.Add(new ProductPictureModel {
SKU = editedProduct.SKU, PicturePath = str, Product = editedProduct
});
}
}
//foreach(ProductPictureModel ppm in editedProduct.ProductPictures) {
// db.Entry(ppm).State = EntityState.Deleted;
//}
editedProduct.ProductPictures.Clear();
editedProduct.ProductCategories.Clear();
string[] selectedSubCategoriesStrings = Request.Form.GetValues("CheckedSubCategories") ?? new string[] { };
List <SubCategoryModel> selectedSubCategoriesList = new List <SubCategoryModel>();
foreach (string str in selectedSubCategoriesStrings)
{
SubCategoryModel subCat = await db.SubCategories.FindAsync(Int32.Parse(str));
selectedSubCategoriesList.Add(subCat);
}
BrandModel brand = await db.Brands.FindAsync(productModel.BrandID);
if (editedProduct.BrandID != productModel.BrandID)
{
brand.Products.Remove(editedProduct);
db.Entry(brand).State = EntityState.Modified;
}
editedProduct.Brand = brand;
editedProduct.BrandID = productModel.BrandID;
editedProduct.CoverPath = productModel.CoverPath;
editedProduct.Description = productModel.Description;
editedProduct.Price = productModel.Price;
editedProduct.ProductCategories = selectedSubCategoriesList;
editedProduct.ProductName = productModel.ProductName;
editedProduct.ProductPictures = ppmLst;
db.Entry(editedProduct).State = EntityState.Modified;
await db.SaveChangesAsync();
return(RedirectToAction("Index"));
}
}
await this.FillViewBag();
ProductModel model = await(from p in db.Products where p.ProductName.ToLower() == productModel.ProductName.ToLower() && p.BrandID == productModel.BrandID select p).FirstAsync();
ViewBag.ProductName = productModel.ProductName;
ViewBag.BrandName = model.Brand.BrandName;
return(View("Error", model));
}
public Task <int> DeleteItemAsync(ProductModel item)
{
return(database.DeleteAsync(item));
}
public ActionResult ProductDetail(string Id)
{
long id = 0;
try
{
id = Convert.ToInt64(CommonFile.Decode(Id));
List<ProductModel> Product = GetProduct(id);
ProductModel objModel = new ProductModel();
if (Product != null && Product.Count() > 0)
{
objModel.Id = id;
objModel.ProductName = Product[0].ProductName;
objModel.ProductCatId = Product[0].ProductCatId;
objModel.ProductImage = Product[0].ProductImage;
objModel.SellingPrice = Product[0].SellingPrice;
objModel.DiscountPrice = Product[0].DiscountPrice;
objModel.BusinessId = Product[0].BusinessId;
objModel.UserId = Product[0].UserId;
objModel.Description = Product[0].Description;
objModel.VendorName = Product[0].VendorName;
objModel.ProductImages = Product[0].ProductImages;
List<ProductImages> ListProductImages = new List<ProductImages>();
if (!String.IsNullOrEmpty(objModel.ProductImages))
{
String[] ProductImages = objModel.ProductImages.Split(',');
ListProductImages = GetSelectedProductImages(ProductImages, objModel.ProductImage);
ViewBag.ProductImages = ListProductImages;
}
else
{
ViewBag.ProductImages = ListProductImages;
}
}
ViewBag.SimilarProductList = ListAllProduct.Where(x => x.ProductCatId == objModel.ProductCatId).ToList(); //ViewBag for showing similar products in the Product Detail Page
ViewBag.ProductCatList = CommonFile.GetProductCategory(null);
var Productlist = ListAllProduct.Where(X => X.Id == id).SingleOrDefault();
var Menuslist = CommonFile.GetProductCategory(null);
if (Menuslist != null && Menuslist.Count > 0)
{
foreach (var mlist in Menuslist)
{
if (mlist.Id == Productlist.ParentCatId)
{
ViewBag.ParentCatDiscription = mlist.Name;
ViewBag.ParentCatId = Productlist.ParentCatId;
break;
}
}
foreach (var mlist in Menuslist)
{
if (mlist.Id == Productlist.ProductCatId)
{
ViewBag.ProductCatDiscription = mlist.Name;
ViewBag.ProductCatId = Productlist.ProductCatId;
break;
}
}
}
return View(objModel);
}
catch (Exception ex)
{
return View("PageNotFound", "Eror");
}
}
public ActionResult Add()
{
var u = new ProductModel();
return(View(u));
}
public async Task <IActionResult> Create(CreateProductViewModel model)
{
if (!ModelState.IsValid)
{
return(View(model));
}
using (var Transaction = Db.Database.BeginTransaction())
{
var product = new ProductModel()
{
Name = model.Name,
Description = model.Description,
StoreID = model.StoreID,
Store = Db.Stores.Where(s => s.ID == model.StoreID).FirstOrDefault(),
DateCreated = DateTime.Now,
Status = ProductStatus.Available,
Images = new List <ImageModel>(),
Variants = new List <VariantModel>()
};
foreach (var formFile in model.Images)
{
if (formFile.Length > 0)
{
var image = ImageUpload.ImageToByte(formFile);
image.Product = product;
product.Images.Add(image);
}
}
await Db.Images.AddRangeAsync(product.Images);
foreach (var variant in model.Variants)
{
var temp = new VariantModel()
{
Name = variant.Name,
Description = variant.Description,
Stock = variant.Stock,
Price = variant.Price,
Currency = CultureInfo.CurrentCulture,
Images = new List <ImageModel>(),
DateCreated = DateTime.Now
};
foreach (var formFile in variant.Images)
{
if (formFile.Length > 0)
{
var image = ImageUpload.ImageToByte(formFile);
image.Variant = temp;
temp.Images.Add(image);
}
}
product.Variants.Add(temp);
await Db.Variants.AddAsync(temp);
await Db.Images.AddRangeAsync(temp.Images);
}
await Db.Products.AddAsync(product);
await Db.SaveChangesAsync();
Transaction.Commit();
}
return(RedirectToAction("List"));
}
public IEnumerable <ProductFieldViewModel> Build([NotNull] ProductModel productModel, [NotNull] string fieldGroup, bool includeBaseProductFields = true, bool includeVariantFields = true, bool includeHiddenFields = false, bool includeEmptyFields = false) => Build(productModel, fieldGroup, CultureInfo.CurrentUICulture, includeBaseProductFields, includeVariantFields, includeHiddenFields, includeEmptyFields);
public async Task <ActionResult <ProductDetails> > UpdateProduct(int id, ProductModel productModel, CancellationToken cancellationToken)
{
return(this.Ok(await this.productService.UpdateProductAsync(id, productModel, cancellationToken)));
}
public void Insert(ProductModel productModel)
{
_mongoCollection.InsertOne(productModel);
}
public async Task <ProductModel> CreateProduct(ProductModel product)
{
var createdProduct = await PostAsync <ProductModel>("api/products", product);
return(createdProduct);
}
public void Update(ProductModel updatedProductModel)
{
var oldProductModel = GetById(updatedProductModel.Id);
oldProductModel.Name = updatedProductModel.Name;
}
private KeyValuePair <RelationshipType, List <ProductItemViewModel> > GetRelatedProducts(ProductModel productModel, string typeName)
{
var relatedModel = _productService.GetProductRelationships(productModel, typeName);
if (relatedModel == null)
{
return(default);
public void Add(ProductModel newProductModel)
{
Products.Add(newProductModel);
}
public ProductListModel() : base()
{
Product = new ProductModel();
}
public ActionResult Demo(ProductModel model)
{
return(Content(model.ProductName + " - " + model.Des));
}
public IActionResult Index(int id)
{
ProductModel productModel = productData.ProductList.FirstOrDefault(p => p.ProductId == id);
return(View(productModel));
}
public ProductModel UpdateProduct([FromBody] ProductModel product)
{
return(_productService.UpdateProduct(product));
}
public ProductArchivesPageViewModel(INavigationService navigationService,
IProductService productService,
IUserService userService,
ITerminalService terminalService,
IWareHousesService wareHousesService,
IAccountingService accountingService,
IDialogService dialogService
) : base(navigationService, productService, terminalService, userService, wareHousesService, accountingService, dialogService)
{
Title = "商品档案";
_navigationService = navigationService;
_dialogService = dialogService;
_terminalService = terminalService;
_productService = productService;
_userService = userService;
_wareHousesService = wareHousesService;
_accountingService = accountingService;
//搜索
this.WhenAnyValue(x => x.Filter.SerchKey)
.Where(s => !string.IsNullOrEmpty(s))
.Select(s => s)
.Throttle(TimeSpan.FromSeconds(2), RxApp.MainThreadScheduler)
.Subscribe(s =>
{
((ICommand)SerchCommand)?.Execute(s);
}).DisposeWith(DeactivateWith);
this.SerchCommand = ReactiveCommand.Create <string>(e =>
{
if (string.IsNullOrEmpty(Filter.SerchKey))
{
this.Alert("请输入关键字！");
return;
}
((ICommand)Load)?.Execute(null);
});
this.Load = ProductSeriesLoader.Load(async() =>
{
//重载时排它
ItemTreshold = 1;
var items = await GetProductsPage(0, PageSize);
//清除列表
ProductSeries?.Clear();
if (items != null && items.Any())
{
foreach (var item in items)
{
if (ProductSeries.Count(s => s.ProductId == item.ProductId) == 0)
{
ProductSeries.Add(item);
}
}
}
if (ProductSeries.Count > 0)
{
this.ProductSeries = new System.Collections.ObjectModel.ObservableCollection <ProductModel>(ProductSeries);
}
return(ProductSeries);
});
//以增量方式加载数据
this.ItemTresholdReachedCommand = ReactiveCommand.Create(async() =>
{
int pageIdex = ProductSeries.Count / PageSize;
using (var dig = UserDialogs.Instance.Loading("加载中..."))
{
try
{
var items = await GetProductsPage(pageIdex, PageSize);
var previousLastItem = ProductSeries.Last();
if (items != null)
{
foreach (var item in items)
{
if (ProductSeries.Count(s => s.ProductId == item.ProductId) == 0)
{
ProductSeries.Add(item);
}
}
if (items.Count() == 0 || items.Count() == ProductSeries.Count)
{
ItemTreshold = -1;
//return this.ProductSeries;
}
}
}
catch (Exception ex)
{
Crashes.TrackError(ex);
ItemTreshold = -1;
}
}
}, this.WhenAny(x => x.ProductSeries, x => x.GetValue().Count > 0));
//选择商品
this.WhenAnyValue(x => x.Selecter).Throttle(TimeSpan.FromMilliseconds(500))
.Skip(1)
.Where(x => x != null)
.SubOnMainThread(async item =>
{
await this.NavigateAsync("AddProductArchivePage", ("Product", item));
Selecter = null;
}).DisposeWith(DeactivateWith);
this.AddCommand = ReactiveCommand.Create <object>(async e => await this.NavigateAsync("AddProductArchivePage"));
this.CatagorySelected = ReactiveCommand.Create <object>(async e =>
{
await SelectCatagory((data) =>
{
Filter.CatagoryId = data.Id;
Filter.CatagoryName = data.Name;
Filter.CatagoryIds = new int[] { data.Id };
});
});
this.BindBusyCommand(Load);
this.Load.ThrownExceptions.Subscribe(ex => { Debug.Print(ex.StackTrace); }).DisposeWith(this.DeactivateWith);
this.SerchCommand.ThrownExceptions.Subscribe(ex => { Debug.Print(ex.StackTrace); }).DisposeWith(this.DeactivateWith);
this.ItemTresholdReachedCommand.ThrownExceptions.Subscribe(ex => { Debug.Print(ex.StackTrace); }).DisposeWith(this.DeactivateWith);
this.AddCommand.ThrownExceptions.Subscribe(ex => { Debug.Print(ex.StackTrace); }).DisposeWith(this.DeactivateWith);
this.CatagorySelected.ThrownExceptions.Subscribe(ex => { Debug.Print(ex.StackTrace); }).DisposeWith(this.DeactivateWith);
}
public ProductModel AddProduct([FromBody] ProductModel product)
{
return(_productService.AddProduct(product));
}
public int Insert(ProductModel product)
{
throw new NotImplementedException();
}
public async Task <IActionResult> SaveProduct([FromBody] ProductModel model)
{
return(Ok(await _productService.SaveProduct(model)));
}
public HttpResponseMessage EditProduct(ProductModel productModel)
{
ResponseModel _response = new ResponseModel();
var _getProduct = _productRepository.FindBy(x => x.ProductId != productModel.ProductId && x.ProductSubCategoryId == productModel.ProductSubCategoryId &&
x.ProductCategoryId == productModel.ProductCategoryId && x.ProductName.Trim().ToLower() == productModel.ProductName.Trim().ToLower() &&
x.Status == (int)Status.Active && x.IsDeleted == false).FirstOrDefault();
if (_getProduct != null)
{
_response.Type = "error";
_response.Message = "Product already Exist";
return(Request.CreateResponse(HttpStatusCode.OK, _response));
}
//var model = Mapper.Map<ProductModel, Product>(productModel);
var _product = _productRepository.FindBy(x => x.ProductId == productModel.ProductId).FirstOrDefault();
_product.ProductId = productModel.ProductId;
_product.ProductCategoryId = productModel.ProductCategoryId;
_product.ProductSubCategoryId = productModel.ProductSubCategoryId;
_product.ProductName = productModel.ProductName;
_product.ProductTypeId = productModel.ProductTypeId;
_product.MarketingCompany = productModel.MarketingCompany;
_product.MRP = productModel.MRP;
_product.PTR = productModel.PTR;
_product.ProductCodeId = productModel.ProductCodeId;
_product.ModifiedBy = productModel.ModifiedBy == null ? productModel.CreatedBy : productModel.ModifiedBy;
_product.ModifiedDate = DateTime.Now;
var IsResponse = _productRepository.EditProduct(_product);
if (IsResponse)
{
// For Uploading image ----
if (productModel.DocProduct != null)
{
UploadDocumentModel UploadDocument = new UploadDocumentModel();
UploadDocument.documents = new List <DocumentModel>();
UploadDocument.ImageSize = 250;
UploadDocument.ImageQuality = 250;
UploadDocument.documents.Add(productModel.DocProduct);
List <string> uploadedFileName = SavePicture(UploadDocument);
if (uploadedFileName.Count > 0)
{
if (_product != null)
{
// delete exiting images
string ImgPath = System.Web.Hosting.HostingEnvironment.MapPath("~/Images/UploadImg/" + _product.ProductImagePath);
if (System.IO.File.Exists(ImgPath))
{
System.IO.File.Delete(ImgPath);
}
string ImgOriginalPath = System.Web.Hosting.HostingEnvironment.MapPath("~/Images/UploadImg/" + "Original_" + _product.ProductImagePath);
if (System.IO.File.Exists(ImgOriginalPath))
{
System.IO.File.Delete(ImgOriginalPath);
}
string TImgPath = System.Web.Hosting.HostingEnvironment.MapPath("~/Images/UploadImg/" + "T" + _product.ProductImagePath);
if (System.IO.File.Exists(TImgPath))
{
System.IO.File.Delete(TImgPath);
}
//------------------------------
_product.ProductImagePath = uploadedFileName[0].ToString();
_productRepository.Update(_product);
_productRepository.SaveChanges();
}
}
}
_response.Type = "success";
_response.Message = "Product updated successfully";
return(Request.CreateResponse(HttpStatusCode.OK, _response));
}
else
{
_response.Type = "error";
_response.Message = "Something went wrong";
return(Request.CreateResponse(HttpStatusCode.OK, _response));
}
}
public async Task <ProductModel> UpdateProduct(Guid id, ProductModel product)
{
var updatedProduct = await PutAsync <ProductModel>($"api/products/{id}", product);
return(updatedProduct);
}
public IActionResult Edit(Guid Id)
{
ProductModel product = GetProductById(Id);
return(View(product));
}
public async Task <IActionResult> Update(ProductModel productModel)
{
var products = await _productApiService.Update(productModel);
return(RedirectToAction("Index"));
}
