public virtual void UpdateProductPicture(ProductDto product, ProductPictureDto model)
{
var productdb = _productService.GetProductById(product.Id);
var productPicture = productdb.ProductPictures.Where(x => x.PictureId == model.PictureId).FirstOrDefault();
if (productPicture == null)
{
throw new ArgumentException("No product picture found with the specified id");
}
productPicture.ProductId = product.Id;
var picture = _pictureService.GetPictureById(productPicture.PictureId);
if (picture == null)
{
throw new ArgumentException("No picture found with the specified id");
}
productPicture.DisplayOrder = model.DisplayOrder;
productPicture.MimeType = picture.MimeType;
productPicture.SeoFilename = model.SeoFilename;
productPicture.AltAttribute = model.AltAttribute;
productPicture.TitleAttribute = model.TitleAttribute;
_productService.UpdateProductPicture(productPicture);
_pictureService.UpdatePicture(picture.Id,
_pictureService.LoadPictureBinary(picture),
picture.MimeType,
model.SeoFilename,
model.AltAttribute,
model.TitleAttribute);
}
public virtual void InsertProductPicture(ProductDto product, ProductPictureDto model)
{
var picture = _pictureService.GetPictureById(model.PictureId);
if (picture != null)
{
_pictureService.UpdatePicture(picture.Id, _pictureService.LoadPictureBinary(picture),
picture.MimeType,
picture.SeoFilename,
model.AltAttribute,
model.TitleAttribute);
_productService.InsertProductPicture(new ProductPicture
{
PictureId = model.PictureId,
ProductId = product.Id,
DisplayOrder = model.DisplayOrder,
AltAttribute = model.AltAttribute,
MimeType = picture.MimeType,
SeoFilename = model.SeoFilename,
TitleAttribute = model.TitleAttribute
});
_pictureService.SetSeoFilename(model.PictureId, _pictureService.GetPictureSeName(product.Name));
}
}
public IActionResult CreateProductPicture(string key, [FromBody] ProductPictureDto productPicture)
{
if (productPicture == null)
{
return(NotFound());
}
if (!_permissionService.Authorize(PermissionSystemName.Products))
{
return(Forbid());
}
var product = _productApiService.GetById(key);
if (product == null)
{
return(NotFound());
}
var pp = product.Pictures.Where(x => x.PictureId == productPicture.PictureId).FirstOrDefault();
if (pp != null)
{
ModelState.AddModelError("", "Product picture mapping found with the specified pictureid");
}
if (ModelState.IsValid)
{
_productApiService.InsertProductPicture(product, productPicture);
return(Ok(true));
}
return(BadRequest(ModelState));
}
public async Task<IActionResult> UpdateProductPicture(string key, [FromBody] ProductPictureDto productPicture)
{
if (productPicture == null)
return NotFound();
if (!await _permissionService.Authorize(PermissionSystemName.Products))
return Forbid();
var product = await _productApiService.GetById(key);
if (product == null)
{
return NotFound();
}
var pp = product.Pictures.Where(x => x.PictureId == productPicture.PictureId).FirstOrDefault();
if (pp == null)
ModelState.AddModelError("", "No product picture mapping found with the specified id");
if (ModelState.IsValid)
{
await _productApiService.UpdateProductPicture(product, productPicture);
return Ok(true);
}
return BadRequest(ModelState);
}
private static PictureCommand ToCommand(this ProductPictureDto picture)
{
return(new PictureCommand
{
Address = picture.Address,
PictureId = picture.PictureId,
Name = picture.Name
});
}
public void InsertProductPicture(ProductPictureDto model)
{
var productPicture = new ProductPicture {
CreatedAt = DateTime.Now, Image = model.Image, ProductId = model.ProductId, IsMain = model.IsMain
};
context.ProductPictures.Add(productPicture);
context.SaveChanges();
}
public FileStreamResult GetProductImageById(Guid id)
{
ProductPictureDto picture = _productPictureService.Get(p => p.Id.Equals(id)).FirstOrDefault();
if (picture != null)
{
return(new FileStreamResult(new FileStream(Server.MapPath(picture.FilePath), FileMode.Open), "image/jpeg"));
}
return(null);
}
public void Delete(ProductPictureDto item)
{
if (Unit != null)
{
Repository.Delete(item, false);
}
else
{
Repository.Delete(item);
}
}
public void Insert(ProductPictureDto item)
{
if (Unit != null)
{
Repository.Insert(item, false);
}
else
{
Repository.Insert(item);
}
}
public void Update(ProductPictureDto item)
{
//if Unit is not null means that the method is called after another method in the service and so it should not save the changes and commit the transaction.
if (Unit != null)
{
Repository.Update(item, false);
}
//if Unit is null means that the method is the first and only method in the transaction and it can save the changes and commit the transaction.
else
{
Repository.Update(item);
}
}
public async Task <GetProductForEditOutput> GetProductForEdit(NullableIdDto <int> input)
{
GetProductForEditOutput productDto;
if (input.Id.HasValue)
{
var product = await _productManager.GetByIdAsync(input.Id.Value);
await _productManager.ProductRepository.EnsureCollectionLoadedAsync(product, t => t.Categories);
await _productManager.ProductRepository.EnsureCollectionLoadedAsync(product, t => t.Pictures);
await _productManager.ProductRepository.EnsureCollectionLoadedAsync(product, t => t.Attributes);
await _productManager.ProductRepository.EnsureCollectionLoadedAsync(product, t => t.AttributeCombinations);
productDto = ObjectMapper.Map <GetProductForEditOutput>(product);
productDto.Categories = product.Categories.ToList().Select(i =>
{
var item = new ProductCategoryDto()
{
Id = i.CategoryId,
};
item.Name = _categoryManager.GetByIdAsync(item.Id).Result?.Name ?? string.Empty;
return(item);
}).ToList();
productDto.Attributes = PrepareProductAttribute(product);
productDto.AttributeCombinations = await PrepareProductAttributeCombination(product);
productDto.Pictures = product.Pictures.OrderBy(p => p.DisplayOrder).ToList().Select(i =>
{
var item = new ProductPictureDto()
{
Id = i.PictureId,
Url = _pictureManager.GetPictureUrl(i.PictureId)
};
return(item);
}).ToList();
}
else
{
productDto = new GetProductForEditOutput();
}
return(productDto);
}
public async Task <IActionResult> UpdateProductPicture(string key, [FromBody] ProductPictureDto productPicture)
{
if (productPicture == null)
{
return(BadRequest());
}
if (!await _permissionService.Authorize(PermissionSystemName.Products))
{
return(Forbid());
}
var product = await _mediator.Send(new GetQuery <ProductDto>() { Id = key });
if (!product.Any())
{
return(NotFound());
}
var pp = product.FirstOrDefault().ProductPictures.Where(x => x.PictureId == productPicture.PictureId).FirstOrDefault();
if (pp == null)
{
ModelState.AddModelError("", "No product picture mapping found with the specified id");
}
if (ModelState.IsValid)
{
var result = await _mediator.Send(new UpdateProductPictureCommand()
{
Product = product.FirstOrDefault(), Model = productPicture
});
return(Ok(result));
}
return(BadRequest(ModelState));
}
public IActionResult Action(ProductModel model, IFormFile Image, List <IFormFile> Images)
{
if (_modelValidations.IsObjectNull(model))
{
return(RedirectToAction("Add", "Products"));
}
var imageUrl = _imageUploader.Upload(Image, Path);
var productDto = new ProductDto {
NameAr = model.NameAr, NameEn = model.NameEn, DescreptionAr = model.DescreptionAr, DescreptionEn = model.DescreptionEn, CategoryId = model.CategoryId, CountryId = model.CountryId, Quantity = model.Quantity
};
var product = _productsRepository.Insert(productDto);
var imageDto = new ProductPictureDto {
ProductId = product.Id, Image = imageUrl, IsMain = true
};
_productsRepository.InsertProductPicture(imageDto);
foreach (var elem in Images)
{
var url = _imageUploader.Upload(elem, Path);
var newImageDto = new ProductPictureDto {
ProductId = product.Id, Image = url, IsMain = false
};
_productsRepository.InsertProductPicture(newImageDto);
}
var measurmentDto = new ProductSpecificationDto {
ProductId = product.Id, MeasurmentId = model.MeasurmentId, Price = model.Price
};
_productsRepository.InsertProductMeasurment(measurmentDto);
return(RedirectToAction("Index", "Products"));
}
public ActionResult Edit(ProductDto product, HttpPostedFileBase[] files)
{
if (ModelState.IsValid)
{
string physicalPath = Server.MapPath(virtualPath);
PictureTransfer[] picTransfers = new PictureTransfer[files.Length];
// specify Picture states
for (int i = 0; i < product.ProductPictures.Count(); i++)
{
ProductPictureDto prodPic = product.ProductPictures.ElementAt(i);
if ((Request.Form["changeRadio_" + i] as string) != null)
{
if ((Request.Form["changeRadio_" + i] as string).Equals("state_deleted"))
{
picTransfers[i] = new PictureTransfer {
State = PictureTransfer.States.Deleted
};
//picTransfers[i].State = PictureTransfer.States.Deleted;
//System.IO.File.Delete(Server.MapPath(prodPic.FilePath));
}
else if ((Request.Form["changeRadio_" + i] as string).Equals("state_updated"))
{
if (files[i] != null)
{
picTransfers[i] = new PictureTransfer
{
State = PictureTransfer.States.Updated,
FileName = files[i].FileName,
ContentType = files[i].ContentType,
ContentLength = files[i].ContentLength,
Stream = files[i].InputStream
};
//System.IO.File.Delete(Server.MapPath(prodPic.FilePath));
//string virtualPath;
//SaveProductPicture(files[i], "~/Images", prodPic, out virtualPath);
//ModifyProductPicture(files[i], prodPic, virtualPath);
}
}
else if ((Request.Form["changeRadio_" + i] as string).Equals("state_unchanged"))
{
picTransfers[i] = new PictureTransfer
{
State = PictureTransfer.States.Unchanged
};
//picTransfers[i].State = PictureTransfer.States.Unchanged;
}
}
else
{
picTransfers[i] = new PictureTransfer
{
State = PictureTransfer.States.Added,
Stream = files[i].InputStream,
ContentType = files[i].ContentType,
FileName = files[i].FileName,
ContentLength = files[i].ContentLength
};
//SaveProductPicture(files[i], "~/Images", prodPic, out virtualPath);
//ModifyProductPicture(files[i], prodPic, virtualPath);
//prodPic.State = "state_added";
}
}
_productService.Update(product, virtualPath, physicalPath, picTransfers);
ViewBag.Success = true;
}
ProductDto prod = _productService.Get(p => p.Id.Equals(product.Id)).FirstOrDefault();
prod.ProductPropertyValues = prod.ProductPropertyValues.OrderBy(p => p.ProductTypePropertyOrderNumber).ToList();
prod.ProductPictures = product.ProductPictures.OrderBy(pp => pp.PictureOrder).ToList();
@ViewBag.PicOrders =
(IEnumerable <SelectListItem>)prod.ProductPictures
.Select(p => new SelectListItem {
Text = p.PictureOrder.ToString(), Value = p.PictureOrder.ToString()
});
return(View("~/Areas/Admin/Views/Products/Edit.cshtml", prod));
}
public static async Task UpdatePicture(ProductDto product, ProductPictureDto model)
{
await product.UpdateProductPicture(model.PictureId, model.MimeType, model.SeoFilename, model.AltAttribute, model.DisplayOrder, model.TitleAttribute).GetValueAsync();
}
public static void AddPictureToProduct(ProductDto product, ProductPictureDto PPD)
{
product.CreateProductPicture(PPD.PictureId, PPD.MimeType, PPD.SeoFilename, PPD.AltAttribute, PPD.DisplayOrder, PPD.TitleAttribute).GetValueAsync().Wait();
}
static void Main(string[] args)
{
TOKEN = WebApiServices.GenerateToken().Result;
container = new Container(new Uri(StoreUrl + "odata"));
container.BuildingRequest += OnBuildingRequest;
var product = WebApiServices.GetProduct().Result;
WebApiServices.UpdatePrice(product.Id, 876);
WebApiServices.UpdateStock(product, "", 1200).Wait();
//pictures
byte[] binary = File.ReadAllBytes("./bill.jpg");
var newPicture = WebApiServices.InsertPicture(binary).Result;
ProductPictureDto newProductPicture = new ProductPictureDto();
newProductPicture.PictureId = newPicture.Id;
newProductPicture.MimeType = newPicture.MimeType;
newProductPicture.SeoFilename = newPicture.SeoFilename;
newProductPicture.AltAttribute = newPicture.AltAttribute;
newProductPicture.TitleAttribute = newPicture.TitleAttribute;
// WebApiServices.AddPictureToProduct(product, newProductPicture);
//5d1613b4be3bff0a8444a7d7
var updatedPicture = product.Pictures.FirstOrDefault();
updatedPicture.DisplayOrder = 4;
WebApiServices.UpdatePicture(product, updatedPicture).Wait();
//WebApiServices.RemoveProductPicture(product, "5d1613b4be3bff0a8444a7d7").Wait();
//product spec
ProductSpecificationAttributeDto spec = new ProductSpecificationAttributeDto();
spec.AllowFiltering = true;
spec.DisplayOrder = 1;
spec.ShowOnProductPage = true;
spec.AttributeType = SpecificationAttributeType.Option;
spec.SpecificationAttributeId = "5d107e372e8d1143384d957";
spec.SpecificationAttributeOptionId = "5d107e372e8d1143384d9580";
//WebApiServices.AddProductSpecification(product, spec).Wait();
ProductSpecificationAttributeDto updateSpec = product.SpecificationAttribute.FirstOrDefault();
updateSpec.AllowFiltering = false;
updateSpec.DisplayOrder = 2;
updateSpec.ShowOnProductPage = false;
updateSpec.SpecificationAttributeId = "5d107e372e8d1143384d9581";
updateSpec.SpecificationAttributeOptionId = "5d107e372e8d1143384d9583";
//WebApiServices.UpdateProductSpecification(product, updateSpec).Wait();
//WebApiServices.RemoveProductSpecification(product, "").Wait();
//tier price
ProductTierPriceDto tierPrice = new ProductTierPriceDto();
tierPrice.Quantity = 50;
tierPrice.Price = 500;
tierPrice.StartDateTimeUtc = DateTime.UtcNow;
tierPrice.EndDateTimeUtc = DateTime.UtcNow.AddDays(5);
// WebApiServices.AddTierPricesToProduct(product, tierPrice).Wait();
ProductTierPriceDto updatedTierPrice = product.TierPrices.FirstOrDefault();
updatedTierPrice.Quantity = 80;
updatedTierPrice.Price = 600;
updatedTierPrice.StartDateTimeUtc = DateTime.UtcNow.AddDays(2);
updatedTierPrice.EndDateTimeUtc = DateTime.UtcNow.AddDays(7);
WebApiServices.UpdateTierPrices(product, updatedTierPrice).Wait();
//WebApiServices.DeleteTierPrices(product,"5d161422be3bff0a8444a83a").Wait();
//manufacturer
ProductManufacturerDto manufacturer = new ProductManufacturerDto();
manufacturer.IsFeaturedProduct = true;
manufacturer.ManufacturerId = "5d107e2e2e8d1143384d9567";
WebApiServices.AddManufacturer(product, manufacturer).Wait();
ProductManufacturerDto updatedManufacturer = new ProductManufacturerDto();
updatedManufacturer.IsFeaturedProduct = false;
updatedManufacturer.ManufacturerId = "5d107e2e2e8d1143384d9567";
WebApiServices.UpdateManufacturer(product, updatedManufacturer).Wait();
//WebApiServices.DeleteManufacturer(product, "5d107e2e2e8d1143384d9567").Wait();
// categories
var categories = WebApiServices.GetCategories().Result.ToList();
var category = categories.FirstOrDefault();
//CategoryDto newCategory = new CategoryDto();
//newCategory.Name = "New category";
//newCategory.SeName = "new-category";
//newCategory.Published = true;
//newCategory.PageSize = 10;
//newCategory.Id = "";
//WebApiServices.InsertCategory(container, newCategory);
WebApiServices.UpdateCategory("5d107df92e8d1143384d9536", "new title22");
//var categoryToDelete = categories.LastOrDefault();
//WebApiServices.DeleteCategory(container, categoryToDelete);
//product category
ProductCategoryDto updatedProductCategory = product.Categories.FirstOrDefault();
updatedProductCategory.IsFeaturedProduct = true;
WebApiServices.UpdateProductCategoryMethod(product.Id, updatedProductCategory).Wait();
//users
var customer = WebApiServices.GetCustomerByEmail(UserName);
var role = WebApiServices.GetFirstCustomerRole(container);
var address = new AddressDto();
address.FirstName = "John";
address.LastName = "Smith";
address.Address1 = "Address 1";
address.Email = "*****@*****.**";
address.City = "New York";
address.PhoneNumber = "111111111";
address.ZipPostalCode = "33333";
address.CreatedOnUtc = DateTime.Now;
address.CountryId = "1";
//WebApiServices.AssignAddressToCustomer(container, address, customer).Wait();
var addressToDelete = customer.Addresses.LastOrDefault();
WebApiServices.DeleteCustomerAddress(addressToDelete, customer).Wait();
}