public async Task <IActionResult> UpdateProduct(ProductResource productResource, int productId)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = _mapper.Map <ProductResource, Product>(productResource);
var response = await _productService.UpdateProduct(product, productId);
if (response.Success)
{
return(Ok(response.Product));
}
return(BadRequest(response.Message));
}
public void ShowTemperatureData(ProductResource productResource)
{
try
{
TemperatureSensor[] sensors = productResource.QueryTemperatureSensors(SensorInfo.Reading);
Temperature = string.Join(", ", sensors
.Select(s => s.Reading.ToString("0.00")));
}
catch (SystemConfigurationException ex) // If device does not have internal temperature sensor(s), display temperature as "N/A".
{
Temperature = NotAvailable;
Error = ex.ErrorCode.ToString();
}
}
public async Task <ActionResult> Update(int id, ProductResource productResource)
{
if (id != productResource.Id)
{
return(BadRequest());
}
var product = mapper.Map <ProductResource, Product>(productResource);
await service.Update(product);
if (product == null)
{
return(NotFound());
}
return(NoContent());
}
public void formatter_withNullStringProperty_propertyIsOmitted()
{
// arrange
var resource = new ProductResource
{
Make = "Ford"
};
// act
var result = TestHelpers.Format.FormatObject(resource, _formatter);
// assert
result.Should().NotContain("model");
result.Should().NotContain("serialNumber");
}
public IActionResult Insert([FromBody] ProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = _mapper.Map <ProductResource, Product>(productResource);
product.CreateTimeStamp = DateTime.UtcNow;
_unitOfWork.Products.Add(product);
_unitOfWork.Complete();
return(Created(new Uri(Request.GetDisplayUrl() + "/" + product.Id), Mapper.Map <Product, ProductResource>(product)));
}
protected async Task ExportProductAsync(IApiContext apiContext, Event eventPayLoad)
{
var productHandler = new ProductExportHandler(_appSetting);
var product = await productHandler.GetProduct(apiContext, eventPayLoad.EntityId);
var productStoreResource = new ProductResource(apiContext);
var sfProd = await productStoreResource.GetProductAsync(product.ProductCode, responseFields : "Content(ProductImages)");
if (sfProd != null)
{
//Get images form storefront product
var images = sfProd.Content.ProductImages;
var productImages = new List <ProductLocalizedImage>();
if (images != null)
{
var documentResource = new DocumentResource(apiContext);
foreach (var image in images)
{
var imageUrl = image.ImageUrl ??
String.Format("//cdn-sb.mozu.com/{0}-m1/cms/files/{1}", apiContext.TenantId,
image.CmsId);
var document = await documentResource.GetDocumentAsync("files@mozu", image.CmsId);
productImages.Add(new ProductLocalizedImage
{
CmsId = image.CmsId,
ImageLabel = document.Name,
//ImageUrl = image.ImageUrl.Replace(image.CmsId, document.Name)
ImageUrl = imageUrl.Replace(image.CmsId, document.Name)
});
}
product.Content.ProductImages = productImages;
}
await productHandler.ExportFileuploadAsync(productImages);
}
//Get Locations for Product
var locations = await GetProductLocations(apiContext, product.ProductCode);
await productHandler.ExportInventoryAsync(apiContext, product, locations);
await productHandler.ExportProductAsync(apiContext, product);
}
public async Task ProductSavedWhenModelStateValid()
{
var productFromMapper = new Product
{
Name = "Name",
QuantityPerBox = 10
};
_mockMapper.Setup(x => x.Map <Product>(It.IsAny <ProductAddResource>())).Returns(productFromMapper);
var productResourceFromMapper = new ProductResource
{
Id = 5,
Name = "Name",
QuantityPerBox = 10
};
_mockMapper.Setup(x => x.Map <ProductResource>(productFromMapper)).Returns(productResourceFromMapper);
Product productModelAfterSaved = null;
_mockUnitOfWork.Setup(x => x.SaveAsync()).ReturnsAsync(true)
.Callback(() => productModelAfterSaved = new Product
{
Id = 5,
Name = productFromMapper.Name,
QuantityPerBox = productFromMapper.QuantityPerBox
});
var productAddResource = new ProductAddResource();
var result = await _sut.CreateProduct(productAddResource);
var createdAtRouteResult = result as CreatedAtRouteResult;
_mockProductRepository.Verify(x => x.AddProduct(It.IsAny <Product>()), Times.Once);
_mockUnitOfWork.Verify(x => x.SaveAsync(), Times.Once);
Assert.IsType <CreatedAtRouteResult>(result);
Assert.NotNull(createdAtRouteResult);
Assert.IsAssignableFrom <IDictionary <string, object> >(createdAtRouteResult.Value);
var dict = createdAtRouteResult.Value as IDictionary <string, object>;
Assert.NotNull(dict);
Assert.Equal(productModelAfterSaved.Id, (int)createdAtRouteResult.RouteValues["id"]);
Assert.Equal(productModelAfterSaved.Name, (string)dict[nameof(productResourceFromMapper.Name)]);
Assert.Equal(productModelAfterSaved.QuantityPerBox, (int)dict[nameof(productResourceFromMapper.QuantityPerBox)]);
}
public async Task <IActionResult> CreateProduct([FromBody] ProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = _mapper.Map <ProductResource, Product>(productResource);
_productRepo.AddProduct(product);
await _unitOfWork.CompleteAsync();
var result = _mapper.Map <Product, ProductResource>(product);
return(Ok(result));
}
public async Task <IActionResult> Create([FromBody] ProductResource data)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var domain = mapper.Map <ProductResource, Product>(data);
_productRepository.Add(domain);
await unitOfWork.CompleteAsync();
var productResource = mapper.Map <Product, ProductResource>(domain);
return(Ok(productResource));
}
public IActionResult UpdateProduct(int id, [FromBody] ProductResource productResource)
{
ValidateProductInput(productResource);
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = productRepository.Get(id);
mapper.Map(productResource, product);
unitOfWork.Complete();
var result = mapper.Map <Product, ProductResource>(product);
return(Ok(result));
}
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] ProductResource productResource)
{
if (productResource == null)
{
productResource = new ProductResource();
}
var product = _mapper.Map <ProductResource, Product>(productResource);
var result = await _productService.UpdateAsync(id, product);
if (!result.Success)
{
return(BadRequest(result));
}
return(Ok(result));
}
public async Task <IActionResult> AddProduct(ProductResource pr)
{
var ProductToAdd = new Product
{
Name = pr.Name,
Quantity = pr.Quantity,
Unit = pr.Unit,
BuyingPrice = pr.Buyingprice,
ShopId = pr.shopid
};
await productRepository.AddProducts(ProductToAdd);
await unitOfWork.CompleteAsync();
return(Ok());
}
/**
* This function will add a new Custom Property to a Magento product and store a catalog item id
* This will serve to tie the two products together
*
* @param magentoProduct Magento product
* @param catalogItemId Identifier for a Catalog Item
*
*/
public void CreateMappingForProduct(ProductResource magentoProduct, string catalogItemId)
{
//Check for a mapping
var mappingAttrValue = GetAttributeByCode(magentoProduct.custom_attributes, ConfigReader.MappingCode);
//mapping already exists? nothing to do!
if (mappingAttrValue != null)
{
return;
}
//Get categories, required for updating product
var magentoCategoryList = (JArray)GetAttributeByCode(magentoProduct.custom_attributes, ConfigReader.MagentoCategoryCode);
var categoryIds = magentoCategoryList.Select(category => int.Parse(category.ToString())).ToList();
_magentoProductController.AddCustomAttributeToProduct(magentoProduct, categoryIds, ConfigReader.MappingCode, catalogItemId);
}
public async Task <IActionResult> AddProduct(ProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
Product product = this._mapper.Map <ProductResource, Product>(productResource);
var productResponse = await this._productService.AddProduct(product);
if (productResponse.Success)
{
return(Ok(productResponse.Extra));
}
return(BadRequest(productResponse.Message));
}
/**
* This function creates a FieldResource given a magento product and an attribute code for a TEXT field
* That means a field where you can only enter text
*
* @param magentoProduct Magento product to parse
* @param attributeCode Attribute code, hard coded value in Magento
*
* @return FieldResource Resource to add to EA product
*/
private static FieldResource CreateFieldFromText(ProductResource magentoProduct, string attrCode)
{
var value = GetAttributeByCode(magentoProduct.custom_attributes, attrCode);
FieldResource field = null;
if (value != null)
{
var fieldId = ConfigReader.GetValueForField(attrCode);
if (fieldId != -1)
{
field = CreateField(ConfigReader.GetValueForField(attrCode), value.ToString());
}
}
return(field);
}
/**
* This function creates a FieldResource given a magento product and an attribute code for a SINGLE SELECT field
* That is a field where you can pick a SINGLE item from a drop down list
*
* @param magentoProduct Magento product to parse
* @param attributeCode Attribute code, hard coded value in Magento
*
* @return FieldResource Resource to add to EA product
*/
private FieldResource CreateFieldFromSingleSelect(ProductResource magentoProduct, string attrCode)
{
var optionId = GetAttributeByCode(magentoProduct.custom_attributes, attrCode);
FieldResource resource = null;
var eaFieldId = ConfigReader.GetValueForField(attrCode);
if (optionId != null && eaFieldId != -1)
{
var attribute = _magentoCustomAttributesController.GetCustomAttributeIfExists(attrCode);
var value = GetLabelFromAttributeValue(attribute.options, optionId.ToString()).ToString();
resource = new FieldResource {
FieldDefinitionId = eaFieldId, LanguageInvariantValue = value
};
}
return(resource);
}
public async Task <IActionResult> AddProduct(ProductResource model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var productResponse = await productService.AddEntityAsync(mapper.Map <Product>(model));
if (productResponse.Success)
{
return(Ok(productResponse.Result));
}
else
{
return(BadRequest(productResponse.Message));
}
}
public async Task <IActionResult> CreateProduct([FromBody] ProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var item = mapper.Map <ProductResource, Product>(productResource);
repository.Add(item);
await unitOfWork.CompleteAsync();
item = await repository.GetProductById(item.ID);
var result = mapper.Map <Product, ProductResource>(item);
return(Ok(result));
}
public IActionResult AddProduct(string name, decimal price, string description)
{
try
{
_productService.AddNewProduct(name, price, description);
_productService.SaveChanges();
ProductResource newProduct = new ProductResource
{
Description = description,
Name = name,
Price = price,
};
return(CreatedAtAction("addProduct", newProduct));
}
catch (Exception)
{
return(BadRequest());
}
}
public async Task <IActionResult> PutLikeAsync(int id, [FromBody] ProductResource productUpdate)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = _mapper.Map <ProductResource, Product>(productUpdate);
var result = await _productService.LikeAsync(id, product);
if (!result.Success)
{
return(BadRequest(result.Message));
}
var productResource = _mapper.Map <Product, ProductResource>(result.Product);
return(Ok(productResource));
}
public async Task <ActionResult> Update(int id, [FromBody] ProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = await _unitOfWork.Products.GetAsync(id);
if (product == null)
{
return(NotFound());
}
_mapper.Map(productResource, product);
await _unitOfWork.CompleteAsync();
return(Ok(_mapper.Map <Product, ProductResource>(product)));
}
public async Task <IActionResult> CreateProductAsync([FromBody] ProductResource productInfo)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = _mapper.Map <ProductResource, Product>(productInfo);
var response = await _productService.CreateProductAsync(product);
if (!response.Success)
{
return(BadRequest(response.Message));
}
var productResource = _mapper.Map <Product, ProductResource>(response.Product);
return(Ok(productResource));
}
public async Task <string> UploadFile([FromForm(Name = "productImage")] IFormFile productImage)
{
var productResource = new ProductResource();
if (productImage != null)
{
string folder = "products/images/";
folder += Guid.NewGuid().ToString() + "_" + productImage.FileName;
productResource.ImagePath = folder;
string serverFolder = Path.Combine(webHostEnvironment.WebRootPath, folder);
await productResource.ProductImage.CopyToAsync(new FileStream(serverFolder, FileMode.Create));
return(serverFolder);
}
return(null);
}
public async Task <IEnumerable <ProductResource> > ListAsync()
{
var products = await _productService.ListAsync();
var resources = products.Select(product =>
{
var productResource = new ProductResource();
productResource.UnitOfMeasurement = product.UnitOfMeasurement.ToDescriptionString();
productResource.Name = product.Name;
productResource.Id = product.Id;
productResource.QuantityInPackage = product.QuantityInPackage;
var categoryResource = new CategoryResource(product.Category.Id, product.Category.Name);
productResource.Category = categoryResource;
return(productResource);
});
return(resources);
}
public async Task <IActionResult> CreateProduct([FromBody] ProductResource p)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Products product = new Products();
product.Name = p.Name;
product.Photo = p.Photo;
product.Price = p.Price;
product.LastUpdate = DateTime.Now;
repository.AddProduct(product);
await unitofwork.Complete();
return(Ok(product));
}
public async Task <IActionResult> PostAsync([FromBody] SaveProductResource resource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
var product = _mapper.Map <Product>(resource);
var result = await _productService.SaveAsync(product);
if (!result.Success)
{
return(BadRequest(result.Message));
}
ProductResource productResource = _mapper.Map <ProductResource>(result.product);
return(Ok(productResource));
}
public IActionResult Update(int id, [FromBody] ProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = _unitOfWork.Products.Get(id);
if (product == null)
{
return(NotFound());
}
_mapper.Map <ProductResource, Product>(productResource, product);
product.UpdateTimeStamp = DateTime.UtcNow;
_unitOfWork.Complete();
return(Ok(Mapper.Map <Product, ProductResource>(product)));
}
/// <summary>
/// This function provides an example of how to create a product in EA given a Magento SKU
/// This function specifically creates a Master Product from a *SIMPLE* Magento Product
///
/// NOTE:
/// This function requires you prepare the product by ensuring it has:
/// - The first category must also be one defined in EA
/// - If manufacturer exists, it will be mapped to a manufacturer in EA
/// - If there are multiple Categories or Manufacturers, the first one will be used
/// - When the product is sucessfully created, an attribute (MappingCode) will be added to each Magento product
/// - If MULTIPLE images are provided, the BASE Magento image will be used as the hero shot
/// </summary>
/// <param name="magentoProduct">Magento product object</param>
/// <returns>ProductDocumentId Identifier of created Product Document</returns>
private static int UpsertSimpleMagentoProductToEa(ProductResource magentoProduct)
{
//Get fields and assets
var fields = _fieldMapper.ParseFieldsFromProduct(magentoProduct);
var assets = _assetMapper.ParseAssetsFromProduct(magentoProduct, ConfigReader.MagentoStorageConfiguration);
var eaCategoryId = _fieldMapper.GetMatchingCategory(magentoProduct.custom_attributes);
var eaManufacturerId = _fieldMapper.GetMatchingManufacturer(magentoProduct.custom_attributes);
var productMapping = _fieldMapper.GetProductMapping(magentoProduct);
//Upsert product
var productDocumentId = _productMapper.UpsertMasterProduct(productMapping, eaCategoryId, ConfigReader.EaClassificationTreeId,
eaManufacturerId, fields, assets);
var slug = _productMapper.CalculateSlug(productDocumentId, null);
if (productMapping == null)
{
//Add to your library
productMapping = _productMapper.AddProductToEndlessAisle(slug);
//Set the mapping on the product so we know it is mapped
_fieldMapper.CreateMappingForProduct(magentoProduct, productMapping);
}
_pricingMapper.UpsertPricingForCatalogItem(productMapping, magentoProduct.price);
//Create availability for product at company level
_availabilityMapper.UpsertAvailabilityForCatalogItem(productMapping, _productMapper.GetQuantityBySku(magentoProduct.sku));
//If we have colors defined, add it as a color definition (if its not already added)
var colorId = _colorMapper.GetMagentoColorAttribute(magentoProduct);
if (colorId != null)
{
_colorMapper.UpsertColorDefinitions(productDocumentId, int.Parse(colorId));
}
return(productDocumentId);
}
public async Task <IActionResult> AddProducts(ProductResource productResource)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.GetErrorMessages()));
}
else
{
Product product = _mapper.Map <ProductResource, Product>(productResource);
var response = await _service.AddProduct(product);
if (response.Success)
{
return(Ok(response.Product));
}
else
{
return(BadRequest(response.Message));
}
}
}
public async Task <IActionResult> Update(int id, [FromBody] ProductResource data)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var product = await _productRepository.GetById(id);
if (product == null)
{
return(NotFound());
}
mapper.Map <ProductResource, Product>(data, product);
await unitOfWork.CompleteAsync();
var productResource = mapper.Map <Product, ProductResource>(product);
return(Ok(productResource));
}
