public void AddMediaToProductTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
// Create a product
var testProduct = createProduct(testCompany, testUser);
var error = ProductService.InsertOrUpdateProduct(testProduct, testUser, "");
Assert.IsTrue(!error.IsError, error.Message);
// Create some media
var sourceFile = GetAppSetting("SiteFolder", "") + "\\Content\\EvolutionLogo.png";
var media = new MediaModel {
};
error = MediaServices.InsertOrUpdateMedia(media, testCompany, testUser, Enumerations.MediaFolder.Product, sourceFile, "", testProduct.Id, -1, FileCopyType.None);
Assert.IsTrue(!error.IsError, error.Message);
// Add the media to the product
var prodMedia = new ProductMediaModel();
error = ProductService.AddMediaToProduct(testProduct, testCompany, testUser, sourceFile, prodMedia, FileCopyType.Copy);
Assert.IsTrue(!error.IsError, error.Message);
// Check that the product has its media attached
var checkProd = db.FindProduct(testProduct.Id);
Assert.IsTrue(checkProd != null, $"Error: A NULL value was returned when an objetc was expected");
var checkProdMedias = checkProd.ProductMedias.ToList();
int expected = 1,
actual = checkProdMedias.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} records were returned when {expected} were expected");
var checkProdMedia = checkProd.ProductMedias.First();
expected = prodMedia.Id;
actual = checkProd.PrimaryMediaId.Value;
Assert.IsTrue(actual == expected, $"Error: The ProductMedia record references Media Id #{actual} when #{expected} were expected");
// Check that the primary media is what was set
var checkMedia = checkProdMedia.Medium;
expected = prodMedia.MediaId;
actual = checkMedia.Id;
Assert.IsTrue(actual == expected, $"Error: Media record Id #{actual} was found when #{expected} was expected");
// Check that the media has a media file
var media2 = MediaServices.FindMediaModel(checkMedia.Id);
var mediaFile = MediaServices.GetMediaFileName(media2, false);
Assert.IsTrue(File.Exists(mediaFile), $"Error: File {mediaFile} was not found");
// Clean up - delete the product
error = ProductService.DeleteProduct(testProduct.Id); // This deletes the media as well
Assert.IsTrue(!error.IsError, error.Message);
}
public void DeleteProductMediaTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
// Create a product
var testProduct = createProduct(testCompany, testUser);
var error = ProductService.InsertOrUpdateProduct(testProduct, testUser, "");
Assert.IsTrue(!error.IsError, error.Message);
// Create some media
var sourceFile = GetAppSetting("SiteFolder", "") + "\\Content\\EvolutionLogo.png";
var media = new MediaModel {
};
error = MediaServices.InsertOrUpdateMedia(media, testCompany, testUser, Enumerations.MediaFolder.Product, sourceFile, "", testProduct.Id, -1, FileCopyType.None);
Assert.IsTrue(!error.IsError, error.Message);
// Add the media to the product
var prodMedia = new ProductMediaModel();
error = ProductService.AddMediaToProduct(testProduct, testCompany, testUser, sourceFile, prodMedia, FileCopyType.Copy);
Assert.IsTrue(!error.IsError, error.Message);
var checkMedia = MediaServices.FindMediaModel(prodMedia.MediaId);
var mediaFile = MediaServices.GetMediaFileName(checkMedia, false);
// Now delete the product media
error = ProductService.DeleteProductMedia(prodMedia.Id);
Assert.IsTrue(!error.IsError, error.Message);
Assert.IsTrue(!File.Exists(mediaFile), $"Error: Media file {mediaFile} was found when it should have been deleted");
}
public Error InsertOrUpdateProductMedia(ProductMediaModel prodMedia, UserModel user, string lockGuid)
{
Error error = validateModel(prodMedia);
if (!error.IsError)
{
// Check that the lock is still current
if (!db.IsLockStillValid(typeof(Product).ToString(), prodMedia.Id, lockGuid))
{
error.SetError(EvolutionResources.errRecordChangedByAnotherUser, "");
}
else
{
// Save the product media
ProductMedia temp = null;
if (prodMedia.Id != 0)
{
temp = db.FindProductMedia(prodMedia.Id);
}
if (temp == null)
{
temp = new ProductMedia();
}
Mapper.Map <ProductMediaModel, ProductMedia>(prodMedia, temp);
db.InsertOrUpdateProductMedia(temp);
prodMedia.Id = temp.Id;
}
}
return(error);
}
public async Task <IActionResult> UploadFile([FromForm] ProductMediaModel productMediaModel)
{
var requestForm = Request.Form;
var file = requestForm.Files[0];
var result = new Result <string>();
var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
var newFileName = $@"{Int32.Parse(productMediaModel.ProdId)}-{fileName}";
try
{
// add image
bool isStoreSuccess = await StoreImage("ProductImages", newFileName, file);
if (!isStoreSuccess)
{
throw new Exception("Store image locally failed.");
}
//add image name to db
ProductMedia productMedia = new ProductMedia {
ProdId = Int32.Parse(productMediaModel.ProdId), Url = $@"Images/ProductImages/{newFileName}"
};
await _context.ProductMedia.AddAsync(productMedia);
await _context.SaveChangesAsync();
result.Data = $@"{fileName} successfully uploaded";
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
return(BadRequest(result));
}
return(Ok(result));
}
public ProductMediaListModel FindProductMediaListModel(int id, int index)
{
var model = new ProductMediaListModel {
GridIndex = index
};
var allItems = db.FindProductMedias(id);
model.TotalRecords = allItems.Count();
foreach (var item in allItems)
{
var media = MediaServices.MapToModel(item.Medium, MediaSize.Medium, (int)MediaSize.MediumW, (int)MediaSize.MediumH);
var newItem = new ProductMediaModel {
Id = item.Id,
ProductId = item.ProductId,
MediaId = item.MediaId,
MediaFile = media.MediaFile,
MediaHtml = media.MediaHtml,
IsPrimary = (item.Id == item.Product.PrimaryMediaId ? true : false)
};
model.Items.Add(newItem);
}
return(model);
}
public async Task <ProductMediaModel> AddProductMediaAsync(ProductMediaModel media)
{
const string sql = "INSERT INTO dbo.ProductMedias (ProductId, YoutubeUrl, ImageId) " +
"OUTPUT INSERTED.Id, INSERTED.ProductId, INSERTED.YoutubeUrl, INSERTED.ImageId " +
"VALUES (@ProductId, @YoutubeUrl, @ImageId);";
return(await connection.QuerySingleAsync <ProductMediaModel>(sql, media));
}
public async Task <IActionResult> PostProductMediaAsync([FromBody] ProductMediaModel media)
{
if (!await productsRepository.IsProductSellerAsync(media.ProductId, int.Parse(User.Identity.Name)))
{
return(BadRequest());
}
return(Ok(await productsRepository.AddProductMediaAsync(media)));
}
public void FindProductMediaListModelTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
// Create a product
var testProduct = createProduct(testCompany, testUser);
var error = ProductService.InsertOrUpdateProduct(testProduct, testUser, "");
Assert.IsTrue(!error.IsError, error.Message);
// Check the media
var productMedias = ProductService.FindProductMediaListModel(testProduct.Id, 0).Items;
int expected = 0,
actual = productMedias.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were returned when {expected} were expected");
// Add some media items
string[] files = { "EvolutionLogo.png",
"IconExclamation.png",
"Processing.gif" };
var prodMediaModels = new List <ProductMediaModel>();
foreach (string fileName in files)
{
var sourceFile = GetAppSetting("SiteFolder", "") + "\\Content\\" + fileName;
var prodMedia = new ProductMediaModel();
error = ProductService.AddMediaToProduct(testProduct, testCompany, testUser, sourceFile, prodMedia, FileCopyType.Copy);
Assert.IsTrue(!error.IsError, error.Message);
prodMediaModels.Add(prodMedia);
}
// Check the media
while (prodMediaModels.Count > 0)
{
productMedias = ProductService.FindProductMediaListModel(testProduct.Id, 0).Items;
expected = prodMediaModels.Count();
actual = productMedias.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were returned when {expected} were expected");
error = ProductService.DeleteProductMedia(prodMediaModels[0].Id);
Assert.IsTrue(!error.IsError, error.Message);
prodMediaModels.RemoveAt(0);
}
// Final check
productMedias = ProductService.FindProductMediaListModel(testProduct.Id, 0).Items;
expected = 0;
actual = productMedias.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were returned when {expected} were expected");
}
// GET: api/ProductMedia/5
public IHttpActionResult Get(int id)
{
var result = new Result <ProductMediaModel>();
ProductMedia productMedia = db.ProductMedias.Find(id);
ProductMediaModel productMediaModel = new ProductMediaModel();
if (productMedia == null)
{
return(Json(DataNotFound(result)));
}
Mapper.Map(productMedia, productMediaModel);
result.Data = productMediaModel;
return(Json(result));
}
public void GetProductImageTest()
{
var testUser = GetTestUser();
var testCompany = GetTestCompany(testUser);
// Create a product
var testProduct = createProduct(testCompany, testUser);
var error = ProductService.InsertOrUpdateProduct(testProduct, testUser, "");
Assert.IsTrue(!error.IsError, error.Message);
// Check the media
var productMedias = ProductService.FindProductMediaListModel(testProduct.Id, 0).Items;
int expected = 0,
actual = productMedias.Count();
Assert.IsTrue(actual == expected, $"Error: {actual} items were returned when {expected} were expected");
// Add a media item
var sourceFile = GetAppSetting("SiteFolder", "") + "\\Content\\EvolutionLogo.png";
var prodMedia = new ProductMediaModel();
error = ProductService.AddMediaToProduct(testProduct, testCompany, testUser, sourceFile, prodMedia, FileCopyType.Copy);
Assert.IsTrue(!error.IsError, error.Message);
// Set it as the primary media
error = ProductService.SetPrimaryMedia(testProduct, prodMedia, testUser, ProductService.LockProduct(testProduct));
Assert.IsTrue(!error.IsError, error.Message);
// Get the image
MediaSize[] sizes = { MediaSize.Large,
MediaSize.Medium,
MediaSize.Small };
foreach (var mediaSize in sizes)
{
string prodImage = ProductService.GetProductImage(testProduct, mediaSize, 10, 10, true).FileName();
Assert.IsTrue(!string.IsNullOrEmpty(prodImage), $"Error: an image URL was expected but an empty/NULL string was returned");
string compare = "EvolutionLogo.png";
Assert.IsTrue(prodImage == compare, $"Error: {prodImage} was returned when {compare} was expected");
}
// Cleanup
error = ProductService.DeleteProduct(testProduct.Id);
Assert.IsTrue(!error.IsError, error.Message);
}
private Boolean GenerateTransferFileModel(ProductMediaModel productMediaModel, out TransferResourceModel transferResourceModel)
{
transferResourceModel = new TransferResourceModel();
if (productMediaModel == null)
{
TraceError("Unable to setup TranferResourceModel. ProductMediaModel is NUll or empty.");
return(false);
}
var fileName = GenerateFileName(productMediaModel);
if (fileName.IsNullOrWhiteSpace())
{
TraceError("Unable to setup TranferResourceModel. Remote fileName cannot be setup.");
return(false);
}
try
{
var source =
new Uri(
string.Format(@"file:///{0}?productId={1}&sequence={2}",
Path.Combine(MediaLocationBasePath, productMediaModel.MediaPath),
productMediaModel.ProductID,
productMediaModel.Sequence),
true);
var destination = new Uri(
string.Format(@"sftp://{0}@{1}/{2}?privateKeyFile={3}", ExportUser, ExportServer.Replace("sftp://", ""), fileName, ExportCertPath), true);
transferResourceModel.Source = source;
transferResourceModel.Destination = destination;
}
catch (Exception e)
{
TraceError("Error setting up TranferResourceModel for product # {1}. Error: {0}", e.Message, productMediaModel.ProductID);
return(false);
}
return(true);
}
public IHttpActionResult Post([FromBody] ProductMediaModel productMediaModel)
{
var result = new Result <ProductMediaModel>();
ProductMedia productMedia = new ProductMedia();
Mapper.Map(productMediaModel, productMedia);
result.Data = productMediaModel;
try
{
db.ProductMedias.Add(productMedia);
db.SaveChanges();
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
result.IsSuccess = false;
return(Json(result));
}
return(Json(result));
}
public Error AddMediaToProduct(ProductModel product,
CompanyModel company,
UserModel user,
string mediaFile,
ProductMediaModel prodMedia, // output
FileCopyType copyType)
{
var error = new Error();
var media = new MediaModel();
error = MediaServices.InsertOrUpdateMedia(media,
company,
user,
MediaFolder.Product,
mediaFile,
"",
product.Id,
-1,
copyType);
if (!error.IsError)
{
var tempProdMedia = db.FindProductMedias(product.Id)
.Where(pm => pm.MediaId == media.Id)
.FirstOrDefault();
if (tempProdMedia == null)
{
// Not currently linked, so link it
tempProdMedia = new ProductMedia {
Id = 0,
ProductId = product.Id,
MediaId = media.Id
};
db.InsertOrUpdateProductMedia(tempProdMedia);
}
Mapper.Map <ProductMedia, ProductMediaModel>(tempProdMedia, prodMedia);
}
return(error);
}
public ActionResult DoUpload(ProductImageUploadViewModel model)
{
var error = new Error();
var product = ProductService.FindProductModel(model.Product.Id, null, null, false);
if (product == null)
{
error.SetRecordError("Product", model.Product.Id);
}
else
{
if (model.Images != null || model.Images.Count() > 0)
{
var fileList = new List <string>();
var targetFolder = MediaServices.GetMediaFolder(CurrentCompany.Id) + "\\Temp\\";
foreach (var file in model.Images)
{
string targetFile = targetFolder + file.FileName;
try {
db.AddFileToLog(targetFile, 2);
file.SaveAs(targetFile);
var prodMedia = new ProductMediaModel();
error = ProductService.AddMediaToProduct(product, CurrentCompany, CurrentUser, targetFile, prodMedia, FileCopyType.Move);
} catch (Exception ex) {
model.SetError(ex, "", true);
break;
}
}
if (!error.IsError)
{
model.SetErrorOnField(ErrorIcon.Information, EvolutionResources.infImagesSuccessfullyUploaded, "", null, null, null, null, true);
}
}
}
return(RedirectToAction("Images", "Images", new { Id = model.Product.Id }));
}
/// <summary>
/// Overriding the Filename for RSO to support 360 sequences and the requested format of filename:
/// Configured: [SKU_SEQ_jpg]
/// Simple: [Barcode_SEQ_jpg]
/// </summary>
/// <param name="media"></param>
/// <param name="path"></param>
/// <returns></returns>
private string GenerateFileName(ProductMediaModel media, string path = "")
{
if (media.TypeID != ImageMediaType.TypeID && media.TypeID != Image360MediaType.TypeID)
{
TraceWarning("Image media type is not supported: {0} for product {1}", media.TypeID, media.ProductID);
return(string.Empty);
}
var sequence = media.Sequence;
if (media.TypeID == Image360MediaType.TypeID)
{
sequence = sequence + 200;
}
if (media.IsConfigurable)
{
return(string.Format(@"{0}/{1}_{2}.jpg", ExportPath, media.VendorItemNumber.Replace(" ", "_"), sequence));
}
return(string.Format(@"{0}/{1}_{2}.jpg", ExportPath, media.Barcode, sequence));
}
public async Task <IActionResult> PutProductMedia(int id, ProductMediaModel productMediaMediaModel)
{
var result = new Result <string>();
Type mediaType = typeof(ProductMedia);
var updateMedia = await _context.ProductMedia.Where(x => x.Id == id).FirstOrDefaultAsync();
if (updateMedia == null)
{
return(NotFound(DataNotFound(result)));
}
UpdateTable(productMediaMediaModel, mediaType, updateMedia);
try
{
await _context.SaveChangesAsync();
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
result.IsSuccess = false;
return(BadRequest(result));
}
return(Ok(result));
}
public IHttpActionResult Put(int id, [FromBody] ProductMediaModel productMediaModel)
{
var result = new Result <string>();
var a = db.ProductMedias.Where(x => x.Id == id).Select(x => x).FirstOrDefault();
if (a == null)
{
return(Json(DataNotFound(result)));
}
Type type = typeof(ProductMedia);
UpdateTable(productMediaModel, type, a);
try
{
db.SaveChanges();
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
result.IsSuccess = false;
return(Json(result));
}
return(Json(result));
}
public Error ImportProducts(CompanyModel company,
UserModel user,
List <string> headings,
string zipImageFile)
{
var error = new Error();
foreach (var row in db.FindFileImportRows(company.Id, user.Id)
.Skip(1) // Skip first record (headers)
.ToList())
{
var brandName = getField(row, "BrandName");
var itemName = getField(row, "ItemName");
var itemNumber = getField(row, "ItemNumber");
var description = getField(row, "ItemDescription");
var unitCBM = getField(row, "UnitCBM");
var minSaleQty = getField(row, "MinSaleQty");
var active = getField(row, "active");
var product = db.FindProduct(itemNumber.Value);
if (product == null)
{
product = new Product {
CreatedDate = DateTimeOffset.Now,
CreatedById = user.Id
}
}
;
product.Brand = db.FindBrand(brandName.Value);
product.ItemName = itemName.Value;
product.ItemNumber = itemNumber.Value;
product.ItemDescription = description.Value;
product.UnitCBM = unitCBM.Value.ParseDouble();
product.MinSaleQty = minSaleQty.Value.ParseInt();
product.Enabled = active.Value.ParseBool();
db.InsertOrUpdateProduct(product);
}
// Import the images for the products
var unfoundCodes = "";
var tempFolder = MediaServices.GetTempFolder() + "ProductImport";
MediaService.MediaService.CreateDirectory(tempFolder);
error = FileCompressionService.Zip.UnzipFile(zipImageFile, tempFolder);
if (!error.IsError)
{
string[] imageList = Directory.GetFiles(tempFolder);
if (imageList != null)
{
foreach (var imageFile in imageList)
{
string prodCode = imageFile.FileName().ChangeExtension("");
// Strip version numbers
int pos1 = prodCode.IndexOf("[");
if (pos1 != -1)
{
prodCode = prodCode.Substring(0, pos1);
}
var product = FindProductModel(prodCode, -1, company, false);
if (product == null)
{
if (!string.IsNullOrEmpty(unfoundCodes))
{
unfoundCodes += ", ";
}
unfoundCodes += imageFile.FileName();
}
else
{
// Create a media item and attach it to the product
var prodMedia = new ProductMediaModel();
error = AddMediaToProduct(product,
company,
user,
imageFile,
prodMedia,
FileCopyType.Move);
if (!error.IsError)
{
// If the product doesn't have a default image, set it to the image just uploaded
if (product.PrimaryMediaId == null)
{
product.PrimaryMediaId = prodMedia.Id;
InsertOrUpdateProduct(product, user, LockProduct(product));
}
}
}
}
}
}
MediaService.MediaService.DeleteDirectory(tempFolder);
return(error);
}
private Error validateModel(ProductMediaModel prodMedia)
{
return(new Error());
}
public async Task <IActionResult> UploadFile([FromForm] ProductMediaModel productMediaModel)
{
var requestForm = Request.Form;
var file = requestForm.Files[0];
var result = new Result <string>();
//var fileName = ContentDispositionHeaderValue.Parse(file.ContentDisposition).FileName.Trim('"');
string fileNameForStorage = Guid.NewGuid().ToString();
//var newFileName = $@"{Int32.Parse(productMediaModel.ProdId)}-{fileName}";
try
{
//add image name to db
if (productMediaModel.ProdId != null)
{
ProductMedia productMedia = new ProductMedia {
ProdId = Int32.Parse(productMediaModel.ProdId), Url = $@"Images/ProductImages/{fileNameForStorage}"
};
await _context.ProductMedia.AddAsync(productMedia);
await _context.SaveChangesAsync();
}
else if (productMediaModel.PackId != null)
{
ProductMedia productMedia = new ProductMedia {
PackId = Int32.Parse(productMediaModel.PackId), Url = $@"Images/ProductImages/{fileNameForStorage}"
};
await _context.ProductMedia.AddAsync(productMedia);
await _context.SaveChangesAsync();
}
else if (productMediaModel.SaleProdId != null)
{
ProductMedia productMedia = new ProductMedia {
SaleProdId = Int32.Parse(productMediaModel.SaleProdId), Url = $@"Images/ProductImages/{fileNameForStorage}"
};
await _context.ProductMedia.AddAsync(productMedia);
await _context.SaveChangesAsync();
}
var bucketName = "luxe_media";
GoogleCredential credential = null;
using (var jsonStream = new FileStream("xxxxx.json", FileMode.Open,
FileAccess.Read, FileShare.Read))
{
credential = GoogleCredential.FromStream(jsonStream);
}
var storageClient = StorageClient.Create(credential);
using (var memoryStream = new MemoryStream())
{
await file.CopyToAsync(memoryStream);
await storageClient.UploadObjectAsync(bucketName, $@"wwwroot/Images/ProductImages/{fileNameForStorage}", "image/jpeg", memoryStream);
memoryStream.Close();
}
result.Data = $@"{fileNameForStorage} successfully uploaded";
}
catch (Exception e)
{
result.ErrorMessage = e.Message;
return(BadRequest(result));
}
return(Ok(result));
}
public Error SetPrimaryMedia(ProductModel product, ProductMediaModel productMedia, UserModel user, string lgs)
{
return(SetPrimaryMedia(product, productMedia.Id, user, lgs));
}
