public void Post(ProductRequestModel productModel)
{
if (ModelState.IsValid)
{
productService.Add(productModel.ToDto());
}
}
public void PostTest()
{
Product product = GetProduct();
ProductRequestModel productRequest = GetProductRequestModel();
ProductResponseModel productResponse = GetProductResponseModel();
_mockRepository
.Setup(repo => repo.Add(product))
.Returns(product);
_mockMapper
.Setup(mapper => mapper.Map <ProductRequestModel, Product>(productRequest))
.Returns(product);
_mockMapper
.Setup(mapper => mapper.Map <Product, ProductResponseModel>(product))
.Returns(productResponse);
IActionResult actionResult = _controller.Post(productRequest);
CreatedAtActionResult actual = (CreatedAtActionResult)actionResult;
string actualName = ((ProductResponseModel)actual.Value).Name;
Assert.Equal(product.Name, actualName);
Assert.Equal(StatusCodes.Status201Created, actual.StatusCode);
}
public async Task When_Product_Is_Not_Active_It_Should_Be_Return_NotFound()
{
Product Product = new Product()
{
Id = "10101",
ProductId = 1000,
ModelId
= 101010,
Name = "Oktay",
OnSale = false
};
var ProductRepositoryMock = new Mock <IProductRepository>();
ProductRepositoryMock.Setup(p => p.GetProductById(1000)).Returns(Task.FromResult(Product));
var ProductController = new ProductController(ProductRepositoryMock.Object);
var ProductRequestModel = new ProductRequestModel()
{
ProductId = 1000
};
var actionResult = await ProductController.GetProductById(ProductRequestModel);
actionResult.Should().BeOfType <NotFoundObjectResult>();
}
public async Task <bool> EditAsync(ProductRequestModel model)
{
try
{
var product = await _context.Products.FirstOrDefaultAsync(m => m.Id == model.Id);
product.Id = model.Id;
product.Name = model.Name;
product.Discription = model.Discription;
product.Supplier = model.Supplier;
product.Price = model.Price;
product.ImageUrl = model.ImageUrl;
product.Modified = DateTime.Now;
product.TotalCount = model.TotalCount;
product.IsSoldOut = model.IsSoldOut;
_context.Products.Attach(product);
_context.Entry(product).State = EntityState.Modified;
return(await _context.SaveChangesAsync() > 0 ? true : false);
}
catch (Exception e)
{
_logger.LogError($"ERROR({nameof(EditAsync)}): {e.Message}");
}
return(false);
}
public string ReplacePlaceholders(string mailContent, ProductRequestModel productRequest)
{
string firstnamePlaceholder = "[FIRSTNAME]",
lastnamePlaceholder = "[LASTNAME]",
companyPlaceholder = "[COMPANY]",
emailPlaceholder = "[EMAIL]",
industryPlaceholder = "[INDUSTRY]",
jobtitlePlaceholder = "[JOBTITLE]",
telephonePlaceholder = "[TELEPHONE]",
productPlaceholder = "[PRODUCT]",
datePlaceholder = "[DATE]",
date = DateTime.Now.Date.ToString("dd MMM yyyy");
//int defaultPort = Request.IsSecureConnection ? 443 : 80;
//var productUrl = Common.GetHyperLink(Common.GetDomainUrl(currentpage.Id, defaultPort), currentpage.Name);
var productUrl = Common.GetHyperLink(currentpage.GetFullNiceUrl(), currentpage.Name);
mailContent = mailContent.Replace(firstnamePlaceholder, productRequest.FirstName)
.Replace(lastnamePlaceholder, productRequest.LastName)
.Replace(jobtitlePlaceholder, productRequest.JobTitle)
.Replace(companyPlaceholder, productRequest.Company)
.Replace(emailPlaceholder, productRequest.Email)
.Replace(industryPlaceholder, ((String.IsNullOrEmpty(productRequest.Industry)) ? String.Empty :
((Umbraco.TypedContent(productRequest.Industry) != null) ? Umbraco.TypedContent(productRequest.Industry).Name : productRequest.Industry)))
.Replace(telephonePlaceholder, productRequest.PhoneNumber)
.Replace(productPlaceholder, productUrl)
.Replace(datePlaceholder, date);
return(mailContent);
}
public async Task <IActionResult> UpdateProduct([FromBody] ProductRequestModel request)
{
try
{
await this.productManager.UpdateProductAsync(new Product
{
_Id = request._Id,
Tag = request.Tag,
Type = request.Type,
Characteristics = request.Characteristics
});
this.responseStatus = new ResponseStatusModel {
Success = true, Message = "Data successfully updated"
};
return(Ok(new { ResponseStatus = this.responseStatus }));
}
catch (ArgumentException ex)
{
this.responseStatus = new ResponseStatusModel {
Success = false, Message = ex.Message, Code = 400
};
return(BadRequest(new { ResponseStatus = this.responseStatus }));
}
}
public void PutTest()
{
Product product = GetProduct();
ProductRequestModel productRequest = GetProductRequestModel();
ProductResponseModel productResponse = GetProductResponseModel();
ValidationResponse <Product> validationResponse = GetOkValidationResponse();
_mockMapper
.Setup(mapper => mapper.Map <ProductRequestModel, Product>(productRequest))
.Returns(product);
_mockService
.Setup(serv => serv.Update(product))
.Returns(validationResponse);
_mockMapper
.Setup(mapper => mapper.Map <Product, ProductResponseModel>(validationResponse.ResponseData))
.Returns(productResponse);
IActionResult actionResult = _controller.Put(_productId, productRequest);
OkObjectResult actual = (OkObjectResult)actionResult;
string actualName = ((ProductResponseModel)actual.Value).Name;
Assert.Equal(product.Name, actualName);
Assert.Equal(StatusCodes.Status200OK, actual.StatusCode);
}
public ActionResult AddProducts(ProductInfo ProductDetails)
{
try
{
if (ModelState.IsValid)
{
HttpPostedFileBase productImage = ProductDetails.Image;
string productImagePath = UploadImageToCloudinery(productImage);
ProductRequestModel Data = new ProductRequestModel()
{
Name = ProductDetails.Name,
Image = productImagePath,
Price = ProductDetails.Price,
Quantity = ProductDetails.Quantity
};
var Result = BusinessLayer.AddProduct(Data);
return(RedirectToAction("ViewProduct", "Product"));
}
return(View());
}
catch (Exception e)
{
throw new ApplicationException(e.Message);
}
}
public Task <object> Handle(AddNewProductRequestCommand command, CancellationToken cancellationToken)
{
if (!command.IsValid())
{
NotifyValidationErrors(command);
}
else
{
Entities.ProductRequest ProductRequest = new Entities.ProductRequest
(
null,
new Name(command.ProductName),
new Description(command.Description),
new Quantity(command.Quantity),
new Status(command.Status),
new Response(command.Response),
new Entities.Customer(new Identity((uint)command.UserId), null, null, null, null, null, null, null, null)
);
ProductRequestModel model = _ProductRequestRepository.Add(ProductRequest);
if (model != null)
{
return(Task.FromResult(model as object));
}
_bus.RaiseEvent(new DomainNotification("ProductRequest", "Server error", NotificationCode.Error));
}
return(Task.FromResult(null as object));
}
public IActionResult Post([FromBody]ProductRequestModel createProductRequest)
{
Product product = _mapper.Map<ProductRequestModel, Product>(createProductRequest);
product = _productRepository.Add(product);
ProductResponseModel productResponse = _mapper.Map<Product, ProductResponseModel>(product);
return CreatedAtAction("Get", new { id = productResponse.Id }, productResponse);
}
public int AddProductWithSP(ProductRequestModel model)
{
var result = _db.Database.ExecuteSqlCommand("SPProduct @p0, @p1,@p2, @p3,@p4, @p5,@p6, @p7, @p8,@p9", parameters: new[] { $"{model.RecordUserId}", $"{model.UpdateUserId}", $"{model.RecordDate}", $"{model.UpdateDate}", $"{model.Name}", $"{model.Description}", $"{model.Imageurl}", $"{model.Price}", $"{model.CategoryId}", $"{model.IsDeleted}" });
return(result);
//var Id = _dbContext.AppLogs
//.FromSqlRaw("SELECT TOP(1) * FROM dbo.[AppLogs] Order by Id desc")
//.FirstOrDefault();
//return Id.Id;
}
public async Task <JsonResult> Action(ProductRequestModel model)
{
if (model.Picture != null && model.Picture.Length > 0 && model.Pictures != null && model.Pictures.Count > 0)
{
var ProductFileName = Guid.NewGuid() + Path.GetExtension(model.Picture.FileName);
var ProductFilePath = Path.Combine(Directory.GetCurrentDirectory(), @"wwwroot\images\Pictures", ProductFileName);
using (var fileStream = new FileStream(ProductFilePath, FileMode.Create))
{
await model.Picture.CopyToAsync(fileStream);
}
if (model.Id == 0)
{
var x = await _IProductService.Create(model.Name, model.Description, model.Price, ProductFileName, model.Pictures, model.CategoryId);
if (x > 0)
{
return(Json(true));
}
return(Json(false));
}
else
{
var x = await _IProductService.Update(model.Id, model.Name, model.Description, model.Price, ProductFileName, model.CategoryId);
if (x > 0)
{
return(Json(true));
}
return(Json(false));
}
}
else if (model.Picture == null && model.Id > 0)
{
var p = _IProductService.getyId(model.Id);
if (p == null)
{
return(Json(false));
}
var y = await _IProductService.Update(model.Id, model.Name, model.Description, model.Price, p.Picture, model.CategoryId);
if (y > 0)
{
return(Json(true));
}
return(Json(false));
}
return(Json(false));
}
public async Task <bool> UpdateProductAsync(ProductRequestModel products)
{
var newProducts = new Product
{
ProductId = products.ProductId,
ProductName = products.ProductName,
Price = products.Price,
PublishStatus = products.PublishStatus
};
return(await _productRepository.UpdateAsync(newProducts));
}
public async Task AddProduct(ProductRequestModel product)
{
if (product == null)
{
throw new ArgumentException("Product can't be null");
}
var mappedCustomer = _mapper.Map <ProductRequestModel, Product>(product);
await _customerContext.Products.AddAsync(mappedCustomer);
_customerContext.SaveChanges();
}
public async Task <IActionResult> Put([FromBody] ProductRequestModel Product)
{
var result = await ProductService.Update(Product);
if (result.HasError)
{
return(BadRequest(result.Errors));
}
else
{
return(Ok("Product successfully updated."));
}
}
public async Task UpdateProduct(int id, ProductRequestModel prouct)
{
var existingProduct = await FindProduct(id);
if (existingProduct == null)
{
throw new KeyNotFoundException();
}
var mapperProduct = _mapper.Map <ProductRequestModel, Product>(prouct, existingProduct);
_customerContext.Products.Update(mapperProduct);
_customerContext.SaveChanges();
}
public async Task <ActionResult> UpdateProduct(int id, ProductRequestModel product)
{
try
{
await _productRepository.UpdateProduct(id, product);
return(Ok());
}
catch (KeyNotFoundException)
{
return(NotFound());
}
}
public Task <BaseResponseModel <bool> > Update(ProductRequestModel model)
{
var config = new MapperConfiguration(cfg => {
cfg.CreateMap <ProductRequestModel, Product>();
});
IMapper iMapper = config.CreateMapper();
var Product = iMapper.Map <ProductRequestModel, Product>(model);
var result = repository.Update(Product);
return(result);
}
public ActionResult Post([FromBody] ProductRequestModel model)
{
if (model == null)
{
return(BadRequest());
}
var mapper = new MapperConfiguration(cfg => cfg.CreateMap <ProductRequestModel, ProductDTO>()).CreateMapper();
var product = mapper.Map <ProductRequestModel, ProductDTO>(model);
db.CreateProduct(product);
return(Ok());
}
public async Task <ProductResponseModel> SaveAsync(ProductRequestModel request)
{
var staleDomain = _mapper.Map <Product>(request);
var currentDomain = await _repository.GetByIdAsync(request.Id);
if (null != currentDomain)
{
staleDomain.CreatedDate = currentDomain.CreatedDate;
staleDomain.UpdatedDate = currentDomain.UpdatedDate;
}
var response = await _repository.SaveAsync(staleDomain);
_session.GetUnitOfWork().CommitChanges();
return(_mapper.Map <ProductResponseModel>(response));
}
public void Put(int id, ProductRequestModel model)
{
//could be improved
if (ModelState.IsValid)
{
var productToBeUpdated = productService.Get(id);
productToBeUpdated.CategoryId = model.CategoryId;
productToBeUpdated.Description = model.Description;
productToBeUpdated.ImageUrl = model.ImageUrl;
productToBeUpdated.Name = model.Name;
productToBeUpdated.Price = model.Price;
productToBeUpdated.IsActive = model.IsActive;
productService.Update(productToBeUpdated);
}
}
public async Task <IActionResult> Create(ProductRequestModel request)
{
if (!ModelState.IsValid)
{
return(View(request));
}
var model = new ProductModel();
ProductMapper.Map(request, model);
await _productService.Create(model, null);
return(RedirectToAction("List"));
}
public async Task Edit(ProductRequestModel item)
{
var content = JsonSerializer.Serialize(item);
var bodyContent = new StringContent(content, Encoding.UTF8, "application/json");
var postResult = await _client.PutAsync("/api/products", bodyContent);
var postContent = await postResult.Content.ReadAsStringAsync();
if (!postResult.IsSuccessStatusCode)
{
throw new ApplicationException(postContent);
}
}
#pragma warning disable CS0108 // Member hides inherited member; missing new keyword
public async Task <IActionResult> Request(ProductRequestModel request)
{
if (ModelState.IsValid)
{
var from = (request.FromEmail != null) ? request.FromEmail : "Anonymous";
var body = $"<p>New part request from: {from}</p><dl><dt>Brand Name:</dt><dd>{request.Part.Brand.Name}</dd><dt>Part Name:</dt><dd>{request.Part.Name}</dd><dt>Part Type:</dt><dd>{request.Part.PartType}</dd></dl>";
await _emailSender.SendEmailAsync("*****@*****.**", "Product Request", "Part Request", body);
TempData["Message"] = "Request sent!";
return(RedirectToAction("Request"));
}
TempData["Message"] = "Request failed to send.";
return(View(request));
}
public ProductResponseModel AddProduct(ProductRequestModel ProductInfo)
{
try
{
if (ProductInfo != null)
{
var Result = _RepositeryLayer.AddProduct(ProductInfo);
return(Result);
}
return(null);
}
catch (Exception e)
{
throw new ApplicationException(e.Message);
}
}
public async Task <IActionResult> GetProductById([FromRoute] ProductRequestModel productRequestModel)
{
var product = await _productRepository.GetProductById(productRequestModel.ProductId);
if (product == null)
{
return(NotFound($"The Product whose id is equal to {productRequestModel.ProductId} cannot be found."));
}
if (!product.OnSale)
{
return(NotFound($"The Product whose id is equal to {productRequestModel.ProductId} is not on sale !"));
}
return(Ok(product));
}
public ActionResult AddProducts(ProductInfo ProductDetails)
{
try
{
ProductRequestModel Data = new ProductRequestModel();
Data.Name = "csdfcsd";
Data.Image = "dfsdfsdfsd";
Data.Price = 131;
Data.Quantity = 12;
var Result = _BusinessLayer.AddProduct(Data);
return(View());
}
catch (Exception e)
{
throw new ApplicationException(e.Message);
}
}
public IActionResult Put(Guid id, [FromBody]ProductRequestModel productRequest)
{
Product product = _mapper.Map<ProductRequestModel, Product>(productRequest);
product.Id = id;
ValidationResponse<Product> validationResponse = _productService.Update(product);
if(validationResponse.Status == ValidationStatus.NotFound)
{
return NotFound(validationResponse.Message);
}
ProductResponseModel productResponse =
_mapper.Map<Product, ProductResponseModel>(validationResponse.ResponseData);
return Ok(productResponse);
}
public async Task When_Product_Is_Given_Null_It_Should_Be_Return_NotFound()
{
Product nullProduct = null;
var ProductRepositoryMock = new Mock <IProductRepository>();
ProductRepositoryMock.Setup(p => p.GetProductById(1000)).Returns(Task.FromResult(nullProduct));
var ProductController = new ProductController(ProductRepositoryMock.Object);
var ProductRequestModel = new ProductRequestModel()
{
ProductId = 1000
};
var actionResult = await ProductController.GetProductById(ProductRequestModel);
actionResult.Should().BeOfType <NotFoundObjectResult>();
}
public async Task <IActionResult> SaveProductById(int id, [FromBody] ProductRequestModel request)
{
var response = new SingleResponse <ProductResponseModel>();
try
{
request.Id = id;
response.Data = await _productService.SaveAsync(request);
}
catch (Exception ex)
{
response.Meta.Code = -1;
response.Meta.ErrorMessage = "Internal server error.";
_logger.Error("There was an error on 'SaveProductById' invocation.", ex);
}
return(response.ToHttpResponse());
}
