public IActionResult Create([FromBody] NewProductViewModel model)
{
if (ModelState.IsValid)
{
_logger.LogInformation("Post message received by create product method");
var product = new DbProduct()
{
Name = model.Name,
SupplierId = model.SupplierId,
CategoryId = model.CategoryId
};
_dataService.Add(product);
return(Ok());
}
return(StatusCode(422));
}
public ActionResult HomeWeb()
{
// Make new Connection to DataBase
ShopDal sdal = new ShopDal();
// make a list from all the data(NewProdect) in the Db.
List <NewProduct> objProduct = sdal.NewproductDB.ToList <NewProduct>();
// object type New Product ViewModel.
NewProductViewModel npvm = new NewProductViewModel();
npvm.newproduct = new NewProduct();
//take the list the we got , and show it in the Home Web.
npvm.newproducts = objProduct;
return(View(npvm));
}
public int?Create(NewProductViewModel product)
{
if (!ModelState.IsValid)
{
return(null);
}
var prod = new Product();
prod.Title = product.Title;
prod.ShortDescription = product.ShortDescription;
prod.Description = HttpUtility.UrlDecode(product.Description, System.Text.Encoding.Default);
prod.BrandId = product.Brand;
prod.ProductGroupId = product.ProductGroup;
prod.Rate = product.Rate;
prod.ShortDescription = product.ShortDescription;
var addProduct = _repo.Add(prod);
#region Adding Product Features
foreach (var feature in product.ProductFeatures)
{
if (feature.IsMain)
{
var model = new ProductMainFeature();
model.ProductId = addProduct.Id;
model.FeatureId = feature.FeatureId;
model.SubFeatureId = feature.SubFeatureId;
model.Value = feature.Value;
model.Quantity = feature.Quantity ?? 0;
model.Price = feature.Price ?? 0;
_repo.AddProductMainFeature(model);
}
else
{
var model = new ProductFeatureValue();
model.ProductId = addProduct.Id;
model.FeatureId = feature.FeatureId;
model.SubFeatureId = feature.SubFeatureId;
model.Value = feature.Value;
_repo.AddProductFeature(model);
}
}
#endregion
return(addProduct.Id);
}
public IActionResult Create(NewProductViewModel model)
{
if (ModelState.IsValid)
{
_logger.LogInformation("Post message received by create product method");
var product = new Product()
{
Name = model.Name,
SupplierId = model.SupplierId,
CategoryId = model.CategoryId
};
_dataService.Add(product);
return(RedirectToAction(nameof(Index)));
}
return(View());
}
public ActionResult Create(NewProductViewModel product)
{
if (ModelState.IsValid)
{
var newProduct = new Product();
newProduct.Name = product.Name;
newProduct.Description = product.Description;
newProduct.Price = product.Price;
newProduct.Category = CategoryService.Instance.GetCategoryID(product.CategoryID);
newProduct.ImageURL = product.ImageURL;
ProductService.Instance.SaveProduct(newProduct);
return(RedirectToAction("TableProduct"));
}
else
{
return(new HttpStatusCodeResult(500));
}
}
public IHttpActionResult Delete(int prodID)
{
using (var db = new DB_Context())
{
try
{
NewProductViewModel obj = new NewProductViewModel();
Product product = db.Products.Where(data => data.ProductID == prodID).FirstOrDefault();
db.Products.Remove(product);
db.SaveChanges();
return(Ok(obj.FinalResult(null, "Delete data Success")));
}
catch (Exception)
{
throw;
}
}
}
public async Task ShouldCallPostReturnOKWhenPassingNewProductViewModel()
{
var viewModel = new NewProductViewModel()
{
Id = Guid.NewGuid(),
Code = "Post Code",
Name = "Post Name"
};
// Act
var jsonInString = JsonConvert.SerializeObject(viewModel);
var response = await client.PostAsync("/api/product/", new StringContent(jsonInString, Encoding.UTF8, "application/json"));
// Assert
var expected = HttpStatusCode.OK;
Assert.Equal(expected, response.StatusCode);
}
public ActionResult Create(NewProductViewModel productModel)
{
if (!ModelState.IsValid)
{
return(new HttpStatusCodeResult(500));
}
var newProduct = new Product();
newProduct.Name = productModel.Name;
newProduct.Description = productModel.Description;
newProduct.Price = productModel.Price;
newProduct.ImageUrl = productModel.ImageUrl;
newProduct.Category = CategoriesService.Instance.GetCategory(productModel.CategoryId);
ProductService.Instance.SaveProduct(newProduct);
return(RedirectToAction("ProductTable"));
}
public ActionResult Create(NewProductViewModel model)
{
if (ModelState.IsValid)
{
var newProduct = new Product();
newProduct.Name = model.Name;
newProduct.Description = model.Description;
newProduct.Price = model.Price;
newProduct.ImageURL = model.ImageURL;
newProduct.Category = CategoriesService.Instance.GetCategory(model.CategoryID);
ProductsService.Instance.SaveProduct(newProduct);
return(RedirectToAction("ProductTable"));
}
else
{
return(new HttpStatusCodeResult(500));
}
}
public ActionResult Create(NewProductViewModel model)
{
//CategoriesService categoryService = new CategoriesService();
//create object of Entity Product
var newProduct = new Product();
newProduct.Name = model.Name;
newProduct.Description = model.Description;
newProduct.Price = model.Price;
newProduct.ImageURL = model.ImageURL;
//newProduct.CategoryID = model.CategoryID;
newProduct.Category = CategoriesService.Instance.GetCategory(model.CategoryID);
ProductsService.Instance.SaveProduct(newProduct);
return(RedirectToAction("ProductTable"));
}
public async Task <IActionResult> NewProduct(NewProductViewModel newProductViewModel)
{
if (ModelState.IsValid)
{
string path = "/" + newProductViewModel.Image.FileName;
using (var fileStream = new FileStream(_appEnvironment.WebRootPath + path, FileMode.Create))
{
await newProductViewModel.Image.CopyToAsync(fileStream);
}
await _productRepository.AddProductAsync(newProductViewModel.Company, newProductViewModel.Name,
newProductViewModel.Price, newProductViewModel.StorageCard, newProductViewModel.Color,
newProductViewModel.OperationSystem, newProductViewModel.Weight, newProductViewModel.Description,
newProductViewModel.Existence, newProductViewModel.Image.FileName);
return(RedirectToAction("Warehouse"));
}
return(View(newProductViewModel));
}
public ActionResult Submit()
{
NewProductViewModel npvm = new NewProductViewModel();
NewProduct objNewProduct = new NewProduct();
int flag = 0;
// Take all the values the manger insert.
objNewProduct.ProductName = Request.Form["newproduct.ProductName"].ToString();
objNewProduct.Price = int.Parse(Request.Form["newproduct.Price"]);
objNewProduct.InitialQuantity = Request.Form["newproduct.InitialQuantity"].ToString();
objNewProduct.ProductId = Request.Form["newproduct.ProductId"].ToString();
ShopDal sdal = new ShopDal();
List <NewProduct> objProduct = sdal.NewproductDB.ToList <NewProduct>();
// Check if the ProductId allready in use
foreach (NewProduct ob in objProduct)
{
if (objNewProduct.ProductId == ob.ProductId)
{
flag = 1;
TempData["Message"] = "Error This key is already in used";
}
}
// if the ProductId is not in used save the new Product in Db
if (ModelState.IsValid && flag == 0)
{
sdal.NewproductDB.Add(objNewProduct);
sdal.SaveChanges();
npvm.newproduct = new NewProduct();
}
else
{
// if the manger insert wrong values, save tha data and Present it again.
npvm.newproduct = objNewProduct;
}
// send the new list to the web , for the manger can show it.
npvm.newproducts = sdal.NewproductDB.ToList <NewProduct>();
return(View("MangerPanel", npvm));
}
public ActionResult Edit(int Id)
{
var Product = _Context.Products.Include(p => p.Category).Single(p => p.Id == Id);
if (Product != null)
{
var ViewModel = new NewProductViewModel
{
Product = Product,
Categories = _Context.Categories.ToList()
};
return(View("ProductForm", ViewModel));
}
else
{
return(HttpNotFound());
}
}
public bool Update(int id, NewProductViewModel request)
{
Product model = UnitOfWork.Product.Find(id);
if (model == null || !model.Active)
{
return(false);
}
else
{
model.Name = request.Name;
model.Color = request.Color;
model.Price = request.Price;
model.Image = request.Image;
UnitOfWork.Entry(model).State = Microsoft.EntityFrameworkCore.EntityState.Modified;
UnitOfWork.SaveChanges();
return(true);
}
}
public ActionResult Edit(int Id)
{
var product = _context.Products.SingleOrDefault(p => p.Id == Id);
if (product == null)
{
return(HttpNotFound());
}
var productSize = _context.ProductSizes.ToList();
var productType = _context.ProductTypes.ToList();
var viewModel = new NewProductViewModel
{
Product = product,
ProductSizes = productSize,
ProductTypes = productType
};
return(View("ProductForm", viewModel));
}
public async Task Save(NewProductViewModel model)
{
Console.WriteLine(model.Description);
var path = await SaveImageToDisk(model.ImageContent);
using var db = _contextFactory.CreateDbContext();
db.TProduct.Add(new TProduct
{
NameFull = model.NameFull,
CategoryId = model.CategoryId,
Description = model.Description,
CreatedTime = DateTimeOffset.Now,
Location = model.Location,
PriceBuy = model.PriceBuy,
PriceSell = model.PriceSell,
Quantity = model.Quantity,
ImagePath = path
});
await db.SaveChangesAsync();
}
public ActionResult Create(NewProductViewModel model)
{
if (ModelState.IsValid)
{
Product product = new Product();
product.Name = model.Name;
product.Description = model.Description;
product.Price = model.Price;
product.Category = categoryService.GetCategory(model.CategoryId);
product.ImageURL = model.ImageURL;
productService.SaveProduct(product);
return(RedirectToAction("ProductTable"));
}
else
{
return(new HttpStatusCodeResult(500));
}
}
void SetupAvailableCatgoriesNew(NewProductViewModel model)
{
using (var entities = new BeerWeb.Models.BeerModel())
{
model.Category = new List <SelectListItem>
{
new SelectListItem {
Value = null, Text = "Choose a category.."
},
};
foreach (var item in entities.Categories)
{
var cat = new SelectListItem {
Value = item.Id.ToString(), Text = item.Name
};
model.Category.Add(cat);
}
;
}
}
public ActionResult Create(NewProductViewModel model)
{
var newProduct = new Product();
newProduct.Name = model.Name;
newProduct.Description = model.Description;
newProduct.Price = model.Price;
newProduct.Category = CategoriesService.Instance.GetCategory(model.CategoryID);
newProduct.ImageURL = model.ImageURL;
newProduct.Vendor = User.Identity.GetUserId();
ProductsService.Instance.SaveProduct(newProduct);
if (User.IsInRole("Admin"))
{
return(RedirectToAction("ProductTable"));
}
else
{
return(RedirectToAction("ProductTableForVendor"));
}
}
public void UpdateProduct(NewProductViewModel product, long CurrentUserID, out bool isSuccess)
{
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
DocumentRepository = unitOfWork.GetRepoInstance <Document>();
ProductRepository = unitOfWork.GetRepoInstance <Product>();
ProductTypeRepository = unitOfWork.GetRepoInstance <ProductType>();
DocumentTypeRepository = unitOfWork.GetRepoInstance <DocumentType>();
UserRepository = unitOfWork.GetRepoInstance <User>();
Product oProduct = ProductRepository.GetByID(Convert.ToInt64(product.Id));
oProduct.UpdatedOn = DateTime.Now;
oProduct.UpdatedUserPID = CurrentUserID;
oProduct.Price = Convert.ToDecimal(product.Price);
if (product.Documents != null)
{
foreach (DocumentViewModel Dviewmodel in product.Documents)
{
Document dcment = new Document();
dcment.ServerPath = Dviewmodel.DocumentPath;
dcment.FileExtension = Dviewmodel.MIMEType;
dcment.DocumentType = DocumentTypeRepository.GetByID((long)EDocumentType.ProfilePhoto);
dcment.Products.Add(oProduct);
DocumentRepository.Insert(dcment);
}
}
unitOfWork.SaveChanges();
//if (product.Price != null)
// transactFactory.CreateTransac(CurrentUserID, null, oProduct.ProductPID, 800, (long)InlineTranscatType.Created);
isSuccess = true;
}
}
catch (Exception ex)
{
LogHelper.WriteErrorLog(ex);
isSuccess = false;
}
}
public List <NewProductViewModel> GetOnlineProducts(int CurrentPage, int PageSize, out long TotalPages)
{
TotalPages = 0;
GenericRepository <Product> ProductRepository;
List <NewProductViewModel> productResult;
productResult = new List <NewProductViewModel>();
try
{
using (UnitOfWork unitOfWork = new UnitOfWork())
{
ProductRepository = unitOfWork.GetRepoInstance <Product>();
IQueryable <Product> lsProd = ProductRepository.GetAllExpressions(x => x.IsPublic == true);
TotalPages = lsProd.Count <Product>();
foreach (Product p in lsProd)
{
NewProductViewModel productVeiwModel = new NewProductViewModel();
productVeiwModel.Id = p.ProductPID.ToString();
productVeiwModel.Description = p.Description;
productVeiwModel.AuctionDate = p.AuctionDate == null ? "" : p.AuctionDate.Value.ToString("dddd, dd MMMM yyyy HH:mm:ss");
//productVeiwModel.Documents.Add(p.Document);
byte[] byteData = System.IO.File.ReadAllBytes(p.Document.ServerPath);
//Convert byte arry to base64string
string imreBase64Data = Convert.ToBase64String(byteData);
productVeiwModel.ImageData = new StringBuilder("data:image/png;base64," + imreBase64Data);
productVeiwModel.Price = p.Price.ToString();
productVeiwModel.ProductName = p.ProductName;
productVeiwModel.ProductCode = p.Code;
productVeiwModel.Quantity = p.Quanity.ToString();
productResult.Add(productVeiwModel);
}
}
}
catch (Exception ex)
{
LogHelper.WriteErrorLog(ex);
}
return(productResult);
}
public ActionResult Update(NewProduct obj)
{
ShopDal sdal = new ShopDal();
NewProductViewModel npvm = new NewProductViewModel();
List <NewProduct> objProduct = sdal.NewproductDB.ToList <NewProduct>();
int flag = 0;
// Take all the values the manger want to update.
obj.ProductId = Request.Form["newproduct.ProductId"].ToString();
obj.InitialQuantity = Request.Form["newproduct.InitialQuantity"].ToString();
//Check if the Id in the list.
foreach (NewProduct ob in objProduct)
{
if (obj.ProductId == ob.ProductId)
{
flag = 1;
}
}
if (flag == 0)
{
TempData["errorId"] = "The Id Product is not in the list.";
return(View("MangerPanel"));
}
// find the product we are looking for by ProductId.
NewProduct np1 =
(from x in sdal.NewproductDB
where x.ProductId == obj.ProductId
select x).ToList <NewProduct>()[0];
// update the new Amount
np1.InitialQuantity = obj.InitialQuantity;
// Save the changes.
sdal.SaveChanges();
// return to the MangerPanel.
return(View("MangerPanel"));
}
public int AddProduct(NewProductViewModel obj, FormCollection data)
{
int id = 0;
using (ApplicationDbContext _context = new ApplicationDbContext())
{
Product modelProduct = new Product();
modelProduct.ProductName = obj.ProductName;
// modelProduct.Quantity = obj.Quantity;
modelProduct.salePrice = obj.salePrice;
modelProduct.purchasePrice = obj.purchasePrice;
modelProduct.CategoryId = obj.CategoryId;
modelProduct.CompanyId = obj.CompanyId;
//long uno = DateTime.Now.Ticks;
//int count = 0;
//foreach (string file_Name in Request.Files)
//{
// HttpPostedFileBase file = Request.Files[file_Name];
// if (!string.IsNullOrWhiteSpace(file.FileName))
// {
// string url = "/Images/PostAdvImages/" + $"{uno}_{++count}" + file.FileName.Substring(file.FileName.LastIndexOf("."));
// string path = Server.MapPath(url);
// file.SaveAs(path);
// objAdv.Images.Add(new AdvertisementImages { Url = url, Priority = count });
// }
//}
modelProduct.ProductImages.Add(new ProductImage {
ImagePath = "as"
});
_context.Products.Add(modelProduct);
_context.SaveChanges();
id = modelProduct.ID;
}
return(id);
}
public IActionResult GetProductById(int id)
{
var product = new NewProduct();
try
{
product = _unitOfWork.Products.GetSingleOrDefault(p => p.Id == id);
}
catch (Exception)
{
throw;
}
if (product != null)
{
var productViewModel = new NewProductViewModel();
productViewModel = Mapper.Map <NewProductViewModel>(product);
return(Ok(productViewModel));
}
return(Ok());
}
public int Save(NewProductViewModel data)
{
Brand brand = UnitOfWork.Brand.Find(data.BrandID);
if (brand == null || !brand.Active)
{
return(-1);
}
var model = new Product
{
Name = data.Name,
Color = data.Color,
Price = data.Price,
Image = data.Image,
FkBrand = brand.IdBrand,
Active = true
};
UnitOfWork.Set <Product>().Add(model);
UnitOfWork.SaveChanges();
foreach (var item in data.CategoriesID)
{
Category categoyTemp = UnitOfWork.Category.Find(item);
if (categoyTemp != null)
{
var productCategory = new ProductByCategory
{
FkProduct = model.IdProduct,
FkCategory = categoyTemp.IdCategory
};
UnitOfWork.Set <ProductByCategory>().Add(productCategory);
UnitOfWork.SaveChanges();
}
}
return(model.IdProduct);
}
public IActionResult CheckIn(NewProductViewModel productViewModel)
{
if (ModelState.IsValid)
{
var imagePath = UploadFile(productViewModel.Image).GetAwaiter().GetResult();
Product product = new Product()
{
Title = productViewModel.Title,
Description = productViewModel.Description,
Price = productViewModel.Price,
Category_Id = productViewModel.CategoryId.Value,
Image = imagePath,
};
_productsRepository.Create(product);
return(View("Index"));
}
return(View("CheckIn"));
}
public IHttpActionResult UpdateProduct(NewProductViewModel newPro)
{
isSuccess = false;
// ipromngmt.CreateProduct(newPro, currentUserID, out isSuccess);
if (isSuccess)
{
var response = new
{
Success = true,
Message = "Created",
};
return(Ok(response));
}
else
{
var response = new
{
Success = false,
Message = "Retry",
};
return(Ok(response));
}
}
public ActionResult NewProduct(NewProductViewModel model)
{
SetupAvailableCatgoriesNew(model);
if (!ModelState.IsValid)
{
return(View(model));
}
using (var entities = new BeerWeb.Models.BeerModel())
{
var newproduct = new Models.Product
{
Category_Id = model.Category_Id,
Name = model.Name,
Description = model.Description,
PicURL = model.PicURL,
Price = model.Price
};
entities.Products.Add(newproduct);
entities.SaveChanges();
return(RedirectToAction("Index", "Category"));
}
}
public ActionResult Create(NewProductViewModel model)
{
if (ModelState.IsValid)
{
var newProduct = new Product();
newProduct.Name = model.Name;
newProduct.Description = model.Description;
newProduct.OriginalPrice = model.OriginalPrice;
newProduct.SellingPrice = model.SellingPrice;
newProduct.stock = model.stock;
newProduct.Tags = model.Tags;
newProduct.Category = db.Categories.Find(model.CategoryID);
newProduct.ImageURL = model.ImageURL;
newProduct.CreatedOn = DateTime.Now;
newProduct.UpdatedOn = DateTime.Now;
db.Products.Add(newProduct);
db.SaveChanges();
return(RedirectToAction("Index"));
}
return(View(model));
}
public IActionResult EditProduct(NewProductViewModel product)
{
if (ModelState.IsValid)
{
if (product == null)
{
return(BadRequest($"{nameof(product)} cannot be null"));
}
var productToEdit = _unitOfWork.Products.Get(product.Id);
productToEdit.Lang = product.Lang;
productToEdit.Description = product.Description;
productToEdit.Code = product.Code;
productToEdit.CorrespondsTo = product.CorrespondsTo;
productToEdit.Name = product.Name;
_unitOfWork.Products.Update(productToEdit);
_unitOfWork.SaveChanges();
return(Ok(product));
}
return(BadRequest(ModelState));
}
