public HttpResponseMessage Create(HttpRequestMessage request, ProductImageViewModel productImageVm)
{
if (ModelState.IsValid)
{
var newImage = new ProductImage();
var identity = (ClaimsIdentity)User.Identity;
IEnumerable <Claim> claims = identity.Claims;
try
{
newImage.UpdateProductImage(productImageVm);
_productImageService.Add(newImage);
_productImageService.Save();
Log log = new Log()
{
AppUserId = claims.FirstOrDefault().Value,
Content = Notification.CREATE_PRODUCTIMG,
Created = DateTime.Now
};
_logService.Create(log);
_logService.Save();
return(request.CreateResponse(HttpStatusCode.OK, productImageVm));
}
catch (Exception dex)
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, dex.Message));
}
}
else
{
return(request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
}
public ProductImage(ProductImageViewModel productImageVm)
{
ProductId = productImageVm.Id;
Path = productImageVm.Path;
Caption = productImageVm.Caption;
SwitchImage = productImageVm.SwitchImage;
}
public async Task <IActionResult> FileUpload(IList <IFormFile> files, IFormCollection data)
{
var ProductID = Convert.ToInt32(data["ProductID"]);
int _count = TempData["LastOrderNo"] != null ? (int)TempData["LastOrderNo"] + 1 : 1;
foreach (IFormFile source in files)
{
string filename = ContentDispositionHeaderValue.Parse(source.ContentDisposition).FileName.ToString().Trim('"');
filename = this.EnsureCorrectFilename(filename);
// "T_ for Thumbnail; O_ for Original
ProductImageViewModel model = new ProductImageViewModel {
ProductID = ProductID, ThumbNailSizeImage = "T_" + filename, OriginalImage = "O_" + filename, IsMainImage = false, Order = _count
};
if (SaveProductImagesDetails(model))
{
// Save Thumnail Image
ResizeImage(source, GetPathAndFilename("T_" + filename, ProductID));
// Save Original Image
using (FileStream output = System.IO.File.Create(GetPathAndFilename("O_" + filename, ProductID)))
{
await source.CopyToAsync(output);
}
}
_count++;
}
return(Ok("Uploaded"));
}
// GET: Admin/SubCategoryOne
public async Task <IActionResult> Index()
{
_logger.LogInformation("Info invoked from ProductController of Index");
var products = await _productService.GetAllProducts();
var listProductViewModel = new List <ProductViewModel>();
foreach (var item in products)
{
ProductViewModel productViewModel = new ProductViewModel
{
ModelNumber = item.ModelNumber,
SerialNumber = item.SerialNumber,
DisplayOrder = item.DisplayOrder,
Price = item.Price,
ProductId = item.PKProductId,
ProductName = item.ProductName,
Quantity = item.Quantity,
ShortDescription = item.ShortDescription,
SubCategoryId = item.SubCategoryOneId.ToString()
};
var prodImages = _productService.GetAllProductImagesById(item.PKProductId);
if (prodImages.Count() > 0)
{
ProductImageViewModel productImageViewModel = AssignProdudctImageToProduct(prodImages);
if (productImageViewModel != null)
{
productViewModel.ProductImageModel.Add(productImageViewModel);
}
}
listProductViewModel.Add(productViewModel);
}
return(View(listProductViewModel));
}
private ProductViewModel GetProductByProductId(int productId)
{
ProductViewModel productViewModel = null;
var retrievedProduct = _productService.GetProductByProductId(productId);
if (retrievedProduct != null)
{
productViewModel = PrepareProductViewModelFromProductEntity(retrievedProduct);
var productImages = _productService.GetAllProductImagesById(retrievedProduct.PKProductId);
if (productImages != null && productImages.Count() > 0)
{
ProductImageViewModel productImageViewModel = AssignProdudctImageToProduct(productImages);
if (productImageViewModel != null)
{
productViewModel.ProductImageModel.Add(productImageViewModel);
}
//productViewModel.ProductImageModel.Add(AssignProdudctImageToProduct(productImages));
}
}
else
{
return(null);
}
return(productViewModel);
}
/// <summary>
/// Get list images
/// </summary>
/// <param name="productId"></param>
/// <returns></returns>
public async Task <List <ProductImageViewModel> > GetListImages(int productId)
{
var productImage = await _context.ProductImages.Where(x => x.ProductId == productId).ToListAsync();
if (productImage == null)
{
throw new EShopException($"Cannot find product with id {productId}");
}
var lstProductImages = new List <ProductImageViewModel>();
foreach (var item in productImage)
{
var productImageViewModel = new ProductImageViewModel()
{
Id = item.Id,
ImagePath = item.ImagePath,
FileSize = item.FileSize,
IsDefault = item.IsDefault
};
lstProductImages.Add(productImageViewModel);
}
return(lstProductImages);
}
public async Task <IActionResult> AddImage(ProductImageViewModel model)
{
if (ModelState.IsValid)
{
var path = string.Empty;
if (model.ImageFile != null)
{
path = await _imageHelper.UploadImageAsync(model.ImageFile);
}
var productImage = new ProductImage
{
ImageUrl = path,
Product = await _dataContext.Products.FindAsync(model.Id)
};
_dataContext.ProductImages.Add(productImage);
await _dataContext.SaveChangesAsync();
return(RedirectToAction($"{nameof(DetailsProduct)}/{model.Id}"));
}
return(View(model));
}
public async Task <ActionResult> AddProduct(CreateProductViewModel cpvm, ProductImageViewModel pivm)
{
var data = "Product Added Failed !";
try
{
var firebase = FirebaseConnection.FirebaseDatabase();
var productImage = FirebaseConnection.FirebaseStorageConnection();
var imageName = new StringBuilder();
if (pivm.imageUploadFirst != null)
{
imageName.Append(DateTime.Now.ToString("dd_MM_yyyy_hhmmss")).Append(Path.GetExtension(pivm.imageUploadFirst.FileName));
var imagePath = await productImage.Child("Product").Child(imageName.ToString()).PutAsync(pivm.imageUploadFirst.InputStream);
cpvm.imageUploadFirst = imagePath;
cpvm.imageUploadFirstName = imageName.ToString();
}
if (pivm.imageUploadSecond != null)
{
imageName = new StringBuilder();
imageName.Append(DateTime.Now.ToString("dd_MM_yyyy_hhmmss")).Append(Path.GetExtension(pivm.imageUploadSecond.FileName));
var imagePath = await productImage.Child("Product").Child(imageName.ToString()).PutAsync(pivm.imageUploadSecond.InputStream);
cpvm.imageUploadSecond = imagePath;
cpvm.imageUploadSecondName = imageName.ToString();
}
if (pivm.imageUploadThird != null)
{
imageName = new StringBuilder();
imageName.Append(DateTime.Now.ToString("dd_MM_yyyy_hhmmss")).Append(Path.GetExtension(pivm.imageUploadThird.FileName));
var imagePath = await productImage.Child("Product").Child(imageName.ToString()).PutAsync(pivm.imageUploadThird.InputStream);
cpvm.imageUploadThird = imagePath;
cpvm.imageUploadThirdName = imageName.ToString();
}
if (pivm.imageUploadFourth != null)
{
imageName = new StringBuilder();
imageName.Append(DateTime.Now.ToString("dd_MM_yyyy_hhmmss")).Append(Path.GetExtension(pivm.imageUploadFourth.FileName));
var imagePath = await productImage.Child("Product").Child(imageName.ToString()).PutAsync(pivm.imageUploadFourth.InputStream);
cpvm.imageUploadFourth = imagePath;
cpvm.imageUploadFourthName = imageName.ToString();
}
UserSession us = new UserSession();
cpvm.userId = us.userId;
var prodAdded = await firebase.Child("productMaster").Child(us.userId).PostAsync(cpvm, true);
data = "Product Added Successfully !";
ModelState.AddModelError("error", data);
}
catch (Exception productAddException)
{
var prodError = productAddException.GetType().GetProperty("Reason").GetValue(productAddException, null);
ModelState.AddModelError("error", prodError.ToString());
return(View());
}
return(RedirectToAction("AddProduct", "Product", new { Status = data }));
}
public ProductImagePage(Product item)
{
InitializeComponent();
_vievModel = new ViewModels.ProductImageViewModel(item);
_item = item;
BindingContext = _vievModel;
DataResource();
}
public IActionResult Create(int?productid)
{
ProductImageViewModel model = new ProductImageViewModel {
IsMainImage = true, ProductID = productid
};
SetProductViewBagID(productid);
return(View(model));
}
public async Task <FileResult> GetProductImage(int ProeuctId)
{
ProductImageViewModel onePC = await IPRR.GetProductImage(ProeuctId);
if (onePC == null)
{
return(null);
}
return(File(onePC.PictureContent, onePC.PictureType));
}
public IResult GetProductImagesForCustomer(int id, bool getAll)
{
var result = new Result
{
Operation = Operation.Read,
Status = Status.Success
};
try
{
var images = _productRepository.GetProductImagesForCustomer(id);
if (images.Count == 0)
{
result.Status = Status.Fail;
result.StatusCode = HttpStatusCode.BadRequest;
result.Message = "Product image does not exist.";
return(result);
}
List <ProductImageViewModel> productImages = new List <ProductImageViewModel>();
if (!getAll)
{
var pdtImage = new ProductImageViewModel();
pdtImage.MapFromModel(images.First());
productImages.Insert(0, pdtImage);
}
else
{
productImages = images.Select(i =>
{
var pdtImage = new ProductImageViewModel();
pdtImage.MapFromModel(i);
return(pdtImage);
}).ToList();
}
ResultModel resultModel = new ResultModel()
{
ProductImageResult = productImages,
TotalCount = productImages.Count
};
result.StatusCode = HttpStatusCode.OK;
result.Status = Status.Success;
result.Body = resultModel;
return(result);
}
catch (Exception e)
{
result.Status = Status.Error;
result.Message = e.Message;
result.StatusCode = HttpStatusCode.InternalServerError;
return(result);
}
}
public async Task <IActionResult> AddEditProductImage(int id)
{
ProductImageViewModel model = new ProductImageViewModel();
model.Categories = GetAllCategories();
if (id > 0)
{
ProductImage pImage = await _unitOfWork.Repository <ProductImage>().GetByIdAsync(id);
model.ProductId = pImage.ProductId;
model.Title = pImage.Title;
}
return(View(model));
}
public IResult GetProductImages(int id)
{
var result = new Result
{
Operation = Operation.Read,
Status = Status.Success
};
try
{
if (id != 0)
{
var pdtImage = _productRepository.GetProductImages(id);
if (pdtImage.Count() == 0)
{
result.StatusCode = HttpStatusCode.BadRequest;
result.Status = Status.Fail;
result.Message = "Product images do not exist.";
return(result);
}
var pdtImageViewList = new List <ProductImageViewModel>();
pdtImageViewList = pdtImage.Select(p =>
{
var pdtImageView = new ProductImageViewModel();
pdtImageView.MapFromModel(p);
return(pdtImageView);
}).ToList();
ResultModel resultModel = new ResultModel();
resultModel.ProductImageResult = pdtImageViewList;
result.Status = Status.Success;
result.StatusCode = HttpStatusCode.OK;
result.Body = resultModel;
return(result);
}
result.StatusCode = HttpStatusCode.BadRequest;
result.Status = Status.Fail;
result.Message = "Product ID is not valid.";
return(result);
}
catch (Exception e)
{
result.Status = Status.Error;
result.Message = e.Message;
result.StatusCode = HttpStatusCode.InternalServerError;
return(result);
}
}
public async Task <IActionResult> Delete(int id)
{
var hasPermission = await _authorizationService.AuthorizeAsync(User, "PRODUCT", Operations.Delete);
if (hasPermission.Succeeded == false)
{
return(new BadRequestObjectResult(CommonConstants.Forbidden));
}
ProductImageViewModel productImageVm = _productImageService.GetById(id);
_productImageService.Delete(id);
_productImageService.SaveChanges();
productImageVm.Path.DeletementByString(_env);
return(new OkObjectResult(id));
}
public ActionResult UploadProductImages(int productId, int listBlobs)
{
var model = new ProductImageViewModel();
model.PageTitle = "Product Image upload - Mowido";
model.ProductId = productId;
CloudStorageAccount storageAccount = CloudStorageAccount.Parse("DefaultEndpointsProtocol=https;AccountName=mowido;AccountKey=9XToqEMRMPAcugE0E8gio2IO1vhm3kZxw6T8gNdIdKOBCQ9PiEHycrvi7uBob2Mk/u5WyNpUSnoESmsxdqFnaw==;EndpointSuffix=core.windows.net");
CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
string containerName = string.Format("product{0}", productId);
CloudBlobContainer container = blobClient.GetContainerReference(containerName);
var isNew = container.CreateIfNotExistsAsync();
if (isNew.ToString() == "true")
{
SetPublicContainerPermissions(container);
}
model.Blobs = new List <string>();
if (listBlobs == 1)
{
foreach (IListBlobItem item in container.ListBlobs(useFlatBlobListing: true))
{
if (item.GetType() == typeof(CloudBlockBlob))
{
CloudBlockBlob blob = (CloudBlockBlob)item;
model.Blobs.Add(blob.Uri.ToString());
}
//else if (item.GetType() == typeof(CloudPageBlob))
//{
// CloudPageBlob blob = (CloudPageBlob)item;
// model.Blobs.Add(blob.Uri.ToString());
//}
//else if (item.GetType() == typeof(CloudBlobDirectory))
//{
// CloudBlobDirectory dir = (CloudBlobDirectory)item;
// model.Blobs.Add(dir.Uri.ToString());
//}
}
}
return(View(model));
}
/// <summary>
/// Convert ProductImage Entity into ProductImage Object
/// </summary>
///<param name="ProductImageEntity">DataAccess.ProductImage</param>
///<returns>ProductImageViewModel</returns>
public static ProductImageViewModel ToViewModel(
this DataAccess.ProductImage entity, ProductImageViewModel viewModel)
{
viewModel.SessionUserId = entity.CreatedUserId;
viewModel.Id = entity.Id;
viewModel.ProductId = entity.ProductId;
viewModel.DocumentId = entity.DocumentId;
viewModel.DocumentNameGuId = entity.Document.DocumentNameGuid;
viewModel.DocumentName = entity.Document.Name;
viewModel.IsActive = entity.IsActive;
viewModel.Ordinal = entity.Ordinal;
viewModel.IsFeatured = entity.IsFeatured;
viewModel.FeaturedImages = entity.FeaturedImages.AsQueryable().ToListViewModel();
return(viewModel);
}
public async Task <IActionResult> Update([FromBody] ProductImageViewModel productImageVm)
{
var hasPermission = await _authorizationService.AuthorizeAsync(User, "PRODUCT", Operations.Update);
if (hasPermission.Succeeded == false)
{
return(new BadRequestObjectResult(CommonConstants.Forbidden));
}
if (ModelState.IsValid)
{
_productImageService.Update(productImageVm);
_productImageService.SaveChanges();
return(new OkObjectResult(productImageVm));
}
return(new BadRequestObjectResult(ModelState));
}
public IActionResult UpdateThumbnailImage(int productId)
{
Product productDb = _productService.GetProductDbById(productId);
try
{
ProductImageViewModel productImageVm = _productImageService.GetProductImageByProdutId(productId).FirstOrDefault();
productDb.ThumbnailImage = productImageVm.Path;
_productService.UpdateDb(productDb);
_productService.SaveChanges();
return(new OkObjectResult(productId));
}
catch (Exception ex)
{
return(new BadRequestObjectResult("Not found image"));
}
}
public async Task<ProductImageViewModel> GetImageById(int imageId)
{
var image = await _context.ProductImages.FindAsync(imageId);
if (image == null) throw new EShopException("Cannot find Image with Id: {imageId}");
var productResult = new ProductImageViewModel()
{
Caption = image.Caption,
DateCreated = image.DateCreated,
FileSize = image.FileSize,
Id = image.Id,
ImagePath = image.ImagePath,
IsDefault = image.IsDefault,
ProductId = image.ProductId,
SortOrder = image.SortOrder
};
return productResult;
}
/// <summary>
///
/// </summary>
/// <param name="productImageVM"></param>
/// <returns></returns>
public async Task <bool> CreateProductImage(ProductImageViewModel productImageVM)
{
if (productImageVM != null)
{
productImage = new ProductImage
{
ProductID = productImageVM.ProductID,
ImageUrl = productImageVM.ImageUrl
};
unitOfWork.ProductImageRepository.Insert(productImage);
}
await unitOfWork.SaveAsync();
return(true);
}
public async Task <ProductImageViewModel> GetImageById(string imageId)
{
var image = await _context.productPhotos.FindAsync(imageId);
if (image == null)
{
throw new WebAPIException($"Cannot find an image with id {imageId}");
}
var viewModel = new ProductImageViewModel()
{
uploadedTime = DateTime.Now,
link = image.link,
idProduct = image.idProduct,
};
return(viewModel);
}
public HttpResponseMessage Update(HttpRequestMessage request, ProductImageViewModel productImageVm)
{
return(CreateHttpResponse(request, () =>
{
if (ModelState.IsValid)
{
ProductImage productImageDb = _productImageService.GetByID(productImageVm.ID);
productImageDb.UpdateProductImage(productImageVm);
_productImageService.Update(productImageDb);
_productImageService.Save();
return request.CreateResponse(HttpStatusCode.OK, productImageVm);
}
else
{
return request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState);
}
}));
}
public async Task <ActionResult <ProductViewModel> > AddProductWithIFormFile(ProductImageViewModel productViewModel)
{
if (!ModelState.IsValid)
{
return(CustomResponse(ModelState));
}
var imgPrefix = Guid.NewGuid() + "_";
if (!await UploadIFormFile(productViewModel.ImageUpload, imgPrefix))
{
return(CustomResponse(ModelState));
}
productViewModel.Image = imgPrefix + productViewModel.ImageUpload.FileName;
await _productService.Add(_mapper.Map <Product>(productViewModel));
return(CustomResponse(productViewModel));
}
public static ProductViewModel ToVm(this Product model, IConfiguration config, ProductViewModel vm = null)
{
if (vm == null)
{
vm = new ProductViewModel();
}
vm.Id = model.Id;
vm.Name = model.ProductName;
vm.Description = model.ProductCode;
vm.UnitPrice = model.UnitPrice;
vm.AvailableQty = model.AvailableQty;
vm.ProductSubCategoryId = model.SubProductCategoryId;
vm.SupplierId = model.SupplierId;
vm.IsActive = model.IsActive.Value;
foreach (var item in model.ProductImages)
{
var image = new ProductImageViewModel()
{
Id = item.Id,
ImageName = item.Name,
ProductId = model.Id
};
//vm.ImageURL = string.Format("{0}/{1}/{2}/{3}", config.GetSection("FileUploadUrl").Value, FolderNames.INSURANCE, model.Vehicle.Id, model.Attachment);
var imagePath = string.Format(@"{0}{1}\{2}\{3}\{4}\{5}\{6}",
config.GetSection("FileUploadPath").Value,
FolderNames.PRODUCT_CATEGORY,
model.SubProductCategory.ProductCategoryId,
FolderNames.PRODUCT_SUB_CATEGORY,
model.SubProductCategoryId,
model.Id,
item.Name);
if (File.Exists(imagePath))
{
vm.Picture = "data:image/jpg;base64," + ImageHelper.getThumnialImage(imagePath);
}
}
return(vm);
}
public async Task <ProductImageViewModel> GetImageById(int imageId)
{
var image = await context.ProductImages.FindAsync(imageId);
if (image == null)
{
throw new LegitProductException($"Không thể tìm thấy hình ảnh với mã {imageId}");
}
var viewModel = new ProductImageViewModel()
{
DateCreated = image.DateCreated,
Id = image.Id,
ImagePath = image.ImagePath,
IsDefault = image.IsDefault,
ProductId = image.ProductId,
};
return(viewModel);
}
public async Task <ApiResult <ProductImageViewModel> > GetImageById(int Image_ID)
{
var image = await _context.ProductImages.FindAsync(Image_ID);
var proImageViewModel = new ProductImageViewModel()
{
Image_ID = image.Image_ID,
Prod_ID = image.Prod_ID,
ImagePath = image.ImagePath,
Caption = image.Caption,
IsDefault = image.IsDefault,
DateCreate = image.DateCreate,
SortOrder = image.SortOrder,
FileSize = image.FileSize,
Product = image.Product,
DateCreated = image.DateCreated,
};
return(new ApiSuccessResult <ProductImageViewModel>(proImageViewModel));
}
public async Task <HttpResponseMessage> UploadProductImage()
{
if (!Request.Content.IsMimeMultipartContent())
{
this.Request.CreateResponse(HttpStatusCode.UnsupportedMediaType);
}
var provider = GetMultipartProvider("~/Content/ProductImageUpload");
var result = await Request.Content.ReadAsMultipartAsync(provider);
var originalFileName = GetDeserializedFileName(result.FileData.First());
string uploadedFileInfo = new FileInfo(result.FileData.First().LocalFileName).ToString();
string[] fileSplit = originalFileName.Split('.');
string fileType = fileSplit[fileSplit.Length - 1];
string destinationFile = uploadedFileInfo + "." + fileType;
System.IO.File.Move(uploadedFileInfo, destinationFile);
string uploadedFileName = destinationFile.Split('\\')[destinationFile.Split('\\').Length - 1];
var fileUploadObj = (UploadDataModelForProduct)GetFormData <UploadDataModelForProduct>(result);
productImageVM = new ProductImageViewModel
{
ProductID = fileUploadObj.productID,
ImageUrl = uploadedFileName
};
await productService.CreateProductImage(productImageVM);
productService.UpdateProductSummaryImage(fileUploadObj.productID, uploadedFileName);
var returnData = productService.GetProductImageByProductID(fileUploadObj.productID);
return(this.Request.CreateResponse(HttpStatusCode.OK, new { returnData }));
}
/// <summary>
/// Convert ProductImage Object into ProductImage Entity
/// </summary>
///<param name="model">ProductImage</param>
///<param name="ProductImageEntity">DataAccess.ProductImage</param>
///<returns>DataAccess.ProductImage</returns>
public static DataAccess.ProductImage ToEntity(
this ProductImageViewModel model,
DataAccess.ProductImage entity)
{
if (entity.Id == 0)
{
entity.CreatedUserId = model.SessionUserId;
}
else
{
entity.IsActive = model.IsActive;
entity.UpdatedUserId = model.SessionUserId;
entity.UpdatedTimestamp = DateTime.Now;
}
entity.ProductId = model.ProductId;
entity.DocumentId = model.DocumentId;
entity.Ordinal = model.Ordinal;
entity.IsFeatured = model.IsFeatured;
return(entity);
}
public async Task <IActionResult> AddImage(int?id)
{
if (id == null)
{
return(NotFound());
}
var product = await _dataContext.Products.FindAsync(id.Value);
if (product == null)
{
return(NotFound());
}
var model = new ProductImageViewModel
{
Id = product.Id
};
return(View(model));
}
