public object Get(Product request)
{
ProductResponse response = new ProductResponse();
response.MaterialTypes = Db.Select<MaterialType>();
var materials = Db.Select<Material>();
foreach (var materialType in response.MaterialTypes)
{
materialType.Materials = materials.Where(item => item.TypeID == materialType.ID).ToList();
}
response.Categories = Db.Select<Category>();
response.Materials = materials;
response.Goods = request.ID > 0 ? Db.SingleById<Goods>(request.ID) : new Goods() { Materials =new List<GoodsMaterial>()};
foreach (var goodsMaterial in response.Goods.Materials)
{
var t=
response.MaterialTypes.FirstOrDefault(
item => item.Materials.Any(m => m.ID == goodsMaterial.MaterialID));
if (t!=null)
{
goodsMaterial.MaterialTypeName = t.Name;
goodsMaterial.MaterialTypeID = t.ID;
}
}
return response;
}
public void CanGetSpecificProduct()
{
//ProductManager myPM = ProductManagerFactory.Create();
ProductFileRepository myPR = new ProductFileRepository(_dataPath + _productTestFile);
ProductResponse productResponse = new ProductResponse();
productResponse = myPR.GetProductByType("Graphite");
Assert.IsFalse(productResponse.Success);
productResponse = myPR.GetProductByType("Granite");
Assert.IsTrue(productResponse.Success);
//Granite,72.5,29.25
Assert.AreEqual("Granite", productResponse.Product.ProductType);
Assert.AreEqual(72.5, productResponse.Product.CostPerSquareFoot);
Assert.AreEqual(29.25, productResponse.Product.LaborCostPerSquareFoot);
}
public IHttpActionResult ProductList(int categoryId = 0, int page = 1)
{
//return BadRequest("Hata Oluştu.");
int pageSize = 12;
var products = (categoryId == 0 ? _productService.GetAll() : _productService.GetAll(_ => _.CategoryId == categoryId)).OrderByDescending(_ => _.Id).ToList();
ProductResponse productResponse = new ProductResponse
{
Products = products.Skip((page - 1) * pageSize).Take(pageSize).ToList(),
PageCount = (int)Math.Ceiling(products.Count / (double)pageSize),
PageSize = pageSize,
CurrentCategory = categoryId,
CurrentPage = page
};
return(Ok(productResponse));
}
public ProductResponse Get()
{
var response = new ProductResponse();
IEnumerable <Product> products = _productRepository.Get();
if (!products.Any())
{
response.Message = "Product not found";
}
else
{
response.Products.AddRange(products);
}
return(response);
}
public ProductResponse Get(int id)
{
var response = new ProductResponse();
var product = _productRepository.Get(id);
if (product == null)
{
response.Message = "Product not found";
}
else
{
response.Products.Add(product);
}
return(response);
}
public async Task <IActionResult> Update([FromRoute] Guid id, [FromBody] productRequest productRequest)
{
var product = await productsService.GetProductAsync(id);
if (product == null)
{
return(NotFound());
}
product.Name = productRequest.Name;
var updateproduct = await productsService.UpdateAsync(product);
var response = new ProductResponse {
Id = updateproduct.Id, Name = updateproduct.Name
};
return(Ok(response));
}
public ProductResponse GetProductByProductType(string productType)
{
ProductResponse response = new ProductResponse();
response.Success = true;
response.product = productRepo.FindByProductType(productType);
if (response.product == null)
{
response.Success = false;
response.Message = "That Product does not exist.";
return(response);
}
response.Success = true;
return(response);
}
public ProductResponse GetProduct(string productType)
{
Product prod = repo.GetProduct(productType);
ProductResponse resp = new ProductResponse();
if (prod == null)
{
resp.Success = false;
resp.Message = "No info for this product...";
}
else
{
resp.Success = true;
resp.Product = prod;
}
return(resp);
}
public async Task <ActionResult <ProductResponse> > Get(
[FromQuery] int?maxprice = null,
[FromQuery] string size = null,
[FromQuery] string highlight = null)
{
var products = await _productService.GetProductsAsync(maxprice, size, highlight);
var productFilter = _productService.GetProductFilter();
var response = new ProductResponse()
{
Products = products,
ProductFilter = productFilter
};
return(Ok(response));
}
public ProductResponse InsertProduct(Product product)
{
var productresponse = new ProductResponse();
var categoryrepo = new CategoryRepo(_context);
try
{
foreach (int category in product.CategoryID)
{
var categoryDB = categoryrepo.GetByID(category);
}
_context.Products.Add(product).State = Microsoft.EntityFrameworkCore.EntityState.Added;
_context.SaveChanges();
foreach (int category in product.CategoryID)
{
var productcategory = new ProductCategory();
productcategory.CategoryID = category;
productcategory.ProductID = product.ProductID;
_context.ProductCategories.Add(productcategory).State = Microsoft.EntityFrameworkCore.EntityState.Added;
}
_context.SaveChanges();
if (product.ProductID != 0)
{
productresponse.ProductID = product.ProductID;
productresponse.Title = product.Title;
productresponse.CompleteDescription = product.CompleteDescription;
productresponse.Height = product.Height;
productresponse.Width = product.Width;
productresponse.Length = product.Length;
productresponse.Weight = product.Weight;
productresponse.BarCode = product.BarCode;
productresponse.Value = product.Value;
productresponse.AcquisitionDate = product.AcquisitionDate;
productresponse.ProductImageLink = product.ProductImageLink;
}
return(productresponse);
}
catch
{
productresponse.ProductID = 0;
return(productresponse);
}
}
//To update products details
public static ProductResponse UpdateProduct(ProductRequest productRequest)
{
auctionEntities = new AuctionSystemEntities();
//create new product response object
ProductResponse productResponse = new ProductResponse();
//retrieve products from product table with productid and customer id
product dbproduct = auctionEntities.products.Where(c => c.id == productRequest.ProductID && c.customer_id == productRequest.CustomerId).FirstOrDefault();
//if product is null
if (dbproduct == null || dbproduct.product_bid_time <= DateTime.Now)
{
//set fault as no auctions for this product
productResponse.Error = new Error {
Code = ErrorCodes.ProductUnavailable, Message = "This product is not available"
};
return(productResponse);
}
//if product is not null then update values for the product from CustomerProduct object
dbproduct.customer_id = productRequest.CustomerId;
dbproduct.product_type_id = productRequest.ProductTypeId;
dbproduct.product_Name = productRequest.ProductName;
dbproduct.product_bid_price = productRequest.ProductBidPrice;
dbproduct.product_bid_time = productRequest.ProductBidTime;
dbproduct.product_description = productRequest.ProductDescription;
dbproduct.status_id = (int)StatusCode.Active;
dbproduct.status_reason_id = (int)StatusReasonCode.ProductIsAvailable;
auctionEntities.SaveChanges();
//create product model object and set updated values to the properties
CustomerProduct.product = new Product();
CustomerProduct.product.CustomerId = dbproduct.customer_id;
CustomerProduct.product.ProductTypeId = dbproduct.product_type_id;
CustomerProduct.product.ProductBidPrice = dbproduct.product_bid_price;
CustomerProduct.product.ProductBidTime = dbproduct.product_bid_time.ToString(format);
CustomerProduct.product.ProductName = dbproduct.product_Name;
CustomerProduct.product.ProductDescription = dbproduct.product_description;
CustomerProduct.product.ProductId = dbproduct.id;
//add productmodel object to list
productResponse.Products = new List <Product>();
productResponse.Products.Add(CustomerProduct.product);
return(productResponse);
}
public async Task DELETE_BadResult_ErrorMsgMatch()
{
var product = OneProduct();
var productResponse = new ProductResponse("Invalid Product ID");
var saveProduct = OneSaveProductResource();
var productService = new Mock <IProductService>();
productService.Setup(x => x.DeleteAsync(product.Id)).ReturnsAsync(
productResponse
);
var sut_productController = new ProductsController(productService.Object, BuildMapper());
var result = await sut_productController.DeleteAsync(product.Id) as BadRequestObjectResult;
Assert.Equal(productResponse.Message, result.Value);
}
public async Task <IActionResult> Get([FromRoute] int id)
{
var product = await _productService.GetById(id);
if (product is null)
{
return(NotFound("Id is not match!"));
}
var result = new ProductResponse()
{
Id = product.Id,
Name = product.Name,
Price = product.Price
};
return(Ok(result));
}
public ProductResponse Update(Product Product)
{
ProductResponse response = new ProductResponse();
try
{
unitOfWork.GetProductRepository().Update(Product);
unitOfWork.Save();
response.Product = Product;
response.Success = true;
}
catch (Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public async Task DeleteAsyncNotFoundTest()
{
// Arrange
var productResponse = new ProductResponse("error");
var service = new Mock <IProductService>();
service.Setup(e => e.GetByIdAsync(It.IsAny <int>())).ReturnsAsync(productResponse);
service.Setup(e => e.DeleteAsync(It.IsAny <int>())).ReturnsAsync(productResponse);
var controller = new ProductsController(service.Object, _mapper);
// Act
var result = await controller.DeleteAsync(1);
// Assert
Assert.IsType <BadRequestObjectResult>(result);
}
public async Task <IActionResult> GetProduct(Guid ProductId)
{
var response = new ProductResponse();
var result = await _dbHelper.GetProduct(ProductId);
if (result == null)
{
response.Code = -100;
response.Message = "Can't get products with given parameters.";
return(Ok(response));
}
response.Code = 100;
response.Message = "Success";
response.Product = result;
return(Ok(response));
}
private async Task <ProductResponse> Save(ProductItem item)
{
Int32 unixTimestamp = (Int32)(DateTime.UtcNow.Subtract(new DateTime(1970, 1, 1))).TotalSeconds;
var request = new ProductRequest
{
Id = EventId,
Timestamp = unixTimestamp.ToString(),
Product = item
};
string json = await GetPost("Product", "SaveProduct", request);
dynamic obj = JsonConvert.DeserializeObject(json);
ProductResponse response = obj == null ? null : obj.ToObject <ProductResponse>();
return(response);
}
public ProductResponse FindProducts()
{
ProductResponse response = new ProductResponse();
response.products = _productRepo.ListProducts();
if (response.products == null)
{
response.Success = false;
response.Message = "Product could not be found";
return(response);
}
else
{
response.Success = true;
}
return(response);
}
public async Task DELETE_OKResult()
{
var product = OneProduct();
var productResponse = new ProductResponse(product);
var saveProduct = OneSaveProductResource();
var productService = new Mock <IProductService>();
productService.Setup(x => x.DeleteAsync(product.Id)).ReturnsAsync(
productResponse
);
var sut_productController = new ProductsController(productService.Object, BuildMapper());
var result = await sut_productController.DeleteAsync(product.Id) as OkObjectResult;
Assert.IsType <OkObjectResult>(result);
}
public async Task <ProductResponse> GetAllAsync()
{
//TODO: Paging...
ProductResponse productResponse = new ProductResponse();
IEnumerable <Product> products = await _productRepository.GetAllAsync();
if (products.ToList().Count == 0)
{
productResponse.Message = "Products not found.";
}
else
{
productResponse.Products.AddRange(products);
}
return(productResponse);
}
public IEnumerable <ProductResponse> GetAllByUser(int?id)
{
if (id == null)
{
return(GetAll(id));
}
var product = _context.Product
.Include(x => x.Holding)
.Include(x => x.Company)
.Include(x => x.User)
.Include(x => x.FotoUpload)
.Include(x => x.Interaction)
.Include(x => x.Category)
.Where(x => x.UserId == id)
.ToList();
return(ProductResponse.FromArray(product, id));
}
public async Task <IActionResult> Create([FromBody] CreateProductRequest productRequest)
{
var Product = new Product
{
SubCategoryId = productRequest.SubCategoryId,
ArabicName = productRequest.ArabicName,
EnglishName = productRequest.EnglishName,
ArabicDescription = productRequest.ArabicDescription,
EnglishDescription = productRequest.EnglishDescription,
Price = productRequest.Price,
Quantity = productRequest.Quantity,
Condition = productRequest.Condition,
Material = productRequest.Material,
status = productRequest.status,
ImgUrl = productRequest.ImgUrl,
colorId = productRequest.colorId,
sizeId = productRequest.sizeId,
CreatedAt = DateTime.Now
};
var status = await _productService.CreateProductAsync(Product);
if (status == -1)
{
return(Conflict(new ErrorResponse
{
message = "Dublicate Entry",
status = Conflict().StatusCode
}));
}
if (status == 1)
{
var response = new ProductResponse {
Id = Product.Id
};
return(Ok(response));
}
return(NotFound(new ErrorResponse
{
message = "Not Found",
status = NotFound().StatusCode
}));
}
public void SaveProduct()
{
bool reLoadList = false;
HttpClient client = new HttpClient();
client.BaseAddress = new Uri(baseUrl);
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/bson"));
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", Token.access_token);
string action = string.Empty;
if (productView.CurrentProduct.Id == 0)
{
//insert
action = insertAction;
reLoadList = true;
}
else
{
action = updateAction;
}
//update
MediaTypeFormatter bsonFormatter = new BsonMediaTypeFormatter();
HttpResponseMessage response = client.PostAsync(action, productView.CurrentProduct, bsonFormatter).Result;
response.EnsureSuccessStatusCode();
MediaTypeFormatter[] formatters = new MediaTypeFormatter[] { bsonFormatter };
ProductResponse productResponse = response.Content.ReadAsAsync <ProductResponse>(formatters).Result;
if (productResponse.Success)
{
if (productResponse.Product != null)
{
if (reLoadList)
{
LoadProducts();
productView.SelectedId = productResponse.Product.Id;
}
}
}
else
{
throw new ProductException(productResponse.ErrorCode, productResponse.ErrorMessage);
}
}
public ActionResult UpdateCustomerProduct(ProductRequest product)
{
LoginModelResponse customerinfo = (LoginModelResponse)Session["Customer"];
if (customerinfo == null)
{
return(RedirectToActionPermanent("Index", "Login"));
}
ProductResponse productResponse = new ProductResponse();
ViewBag.LoginSuccess = "True";
if (!ModelState.IsValid)
{
TempData["Error"] = "All Fields are required";
return(RedirectToAction("DisplayCustomerProduct", new { productid = product.ProductID }));
}
using (var client = new HttpClient())
{
client.BaseAddress = new Uri(ConfigurationManager.AppSettings["WebApiBaseUrl"]);
product.CustomerId = customerinfo.CustomerId;
//HTTP POST
var responseMessageTask = client.PostAsJsonAsync <ProductRequest>("api/Product/UpdateProduct", product);
responseMessageTask.Wait();
var responseMessage = responseMessageTask.Result;
if (responseMessage.IsSuccessStatusCode)
{
var responseContentTask = responseMessage.Content.ReadAsAsync <ProductResponse>();
responseContentTask.Wait();
productResponse = responseContentTask.Result;
if (productResponse.Error == null)
{
return(RedirectToActionPermanent("GetCustomerProducts", "Product"));
}
TempData["Error"] = productResponse.Error.Message;
return(RedirectToAction("DisplayCustomerProduct", new { productid = product.ProductID }));
}
TempData["Error"] = "server error";
return(RedirectToAction("DisplayCustomerProduct", new { productid = product.ProductID }));
}
}
//To retrieve products with customerid
public static ProductResponse GetCustomerProducts(int customerId)
{
auctionEntities = new AuctionSystemEntities();
ProductResponse productResponse = new ProductResponse();
//retrieve products from product table with customerid
product[] products = auctionEntities.products.Where(c => c.customer_id == customerId).ToArray();
//if empty set fault
if (products == null)
{
productResponse.Error = new Error {
Code = ErrorCodes.ProductsUnavailable, Message = "This customer does not have any products"
};
return(productResponse);
}
productResponse.Products = new List <Product>();
//if array is not null then loop through each item in array
foreach (product product in products)
{
CustomerProduct.product = new Product();
var userAuction = auctionEntities.auctions.Where(c => c.product_id == product.id).ToList();
if (userAuction.Count != 0)
{
var currentHighestBid = userAuction.Max(p => p.bid_price);
CustomerProduct.product.CurrentHighestBid = currentHighestBid;
}
CustomerProduct.product.CustomerId = product.customer_id;
CustomerProduct.product.ProductTypeId = product.product_type_id;
CustomerProduct.product.ProductBidPrice = product.product_bid_price;
CustomerProduct.product.ProductBidTime = product.product_bid_time.ToString(format);
CustomerProduct.product.ProductName = product.product_Name;
CustomerProduct.product.ProductDescription = product.product_description;
CustomerProduct.product.MaxPrice = product.max_price;
CustomerProduct.product.ProductId = product.id;
CustomerProduct.product.Status = product.customer_status.status;
CustomerProduct.product.StatusReason = product.status_reason.reason;
productResponse.Products.Add(CustomerProduct.product);
}
return(productResponse);
}
/// <summary>
/// Validate request
/// </summary>
/// <param name="request"></param>
/// <param name="response"></param>
public void Validate(ProductRequest request, out ProductResponse response)
{
response = new ProductResponse();
if (request.Action != null && request.Action.Equals(ClinicEnums.Action.DELETE.ToString()))
{
ValidateForDelete(request, out response);
}
else
{
bool isHavePrivilege = true;
if (request.Data.Name == null || String.IsNullOrWhiteSpace(request.Data.Name))
{
errorFields.Add("Product Name");
}
if (errorFields.Any())
{
response.Status = false;
response.Message = string.Format(Messages.ValidationErrorFields, String.Join(",", errorFields));
}
if (request.Data.Id == 0)
{
isHavePrivilege = IsHaveAuthorization(ADD_PRIVILEGE_NAME, request.Data.Account.Privileges.PrivilegeIDs);
}
else
{
isHavePrivilege = IsHaveAuthorization(EDIT_PRIVILEGE_NAME, request.Data.Account.Privileges.PrivilegeIDs);
}
if (!isHavePrivilege)
{
response.Status = false;
response.Message = Messages.UnauthorizedAccess;
}
if (response.Status)
{
response = new ProductHandler(_unitOfWork).CreateOrEdit(request);
}
}
}
/// <summary>
/// Requests product data.
/// </summary>
/// <param name="request">Product request message.</param>
/// <returns>Product response message.</returns>
public ProductResponse GetProducts(ProductRequest request)
{
ProductResponse response = new ProductResponse();
response.CorrelationId = request.RequestId;
// Validate client tag and access token
if (!ValidRequest(request, response, Validate.ClientTag | Validate.AccessToken))
{
return(response);
}
ProductCriteria criteria = request.Criteria as ProductCriteria;
if (request.LoadOptions.Contains("Categories"))
{
IEnumerable <Category> categories = productDao.GetCategories();
response.Categories = Mapper.ToDataTransferObjects(categories);
}
if (request.LoadOptions.Contains("Products"))
{
IEnumerable <Product> products = productDao.GetProductsByCategory(criteria.CategoryId, criteria.SortExpression);
response.Products = Mapper.ToDataTransferObjects(products);
}
if (request.LoadOptions.Contains("Product"))
{
Product product = productDao.GetProduct(criteria.ProductId);
product.Category = productDao.GetCategoryByProduct(criteria.ProductId);
response.Product = Mapper.ToDataTransferObject(product);
}
if (request.LoadOptions.Contains("Search"))
{
IList <Product> products = productDao.SearchProducts(criteria.ProductName,
criteria.PriceFrom, criteria.PriceThru, criteria.SortExpression);
response.Products = Mapper.ToDataTransferObjects(products);
}
return(response);
}
public IList <Category> GetCategories()
{
ProductRequest request = new ProductRequest();
request.RequestId = NewRequestId;
request.AccessToken = AccessToken;
request.ClientTag = ClientTag;
request.LoadOptions = new string[] { "Categories" };
ProductResponse response = ActionServiceClient.GetProducts(request);
if (request.RequestId != response.CorrelationId)
{
throw new ApplicationException("GetCategories: RequestId and CorrelationId do not match.");
}
return(response.Categories);
}
public async Task <ProductResponse <ProductView> > SaveProduct([FromBody] ProductView productView)
{
try
{
if (!ModelState.IsValid)
{
throw new ProductException(ModelState.GetErrors());
}
var product = ProductMapper.ToProduct(productView);
await ProductService.SaveProductAsync(product);
productView = ProductMapper.ToView(product);
return(ProductResponse <ProductView> .Create("Operation successfully.", productView));
}
catch (Exception e)
{
return(ProductResponse <ProductView> .Create($"Server Error: { e.Message }"));
}
}
public async Task <ProductResponse <ProductView> > FindProductById(int id)
{
try
{
var product = await ProductService.FindProductByIdAsync(id);
if (product == null)
{
throw new ProductException("Product doesn't exist.");
}
var productView = ProductMapper.ToView(product);
return(ProductResponse <ProductView> .Create("Operation successfully.", productView));
}
catch (Exception e)
{
return(ProductResponse <ProductView> .Create($"Server Error: { e.Message }"));
}
}
public async Task <Response> PostQualificationAsync(string urlBase, string servicePrefix, string controller, QualificationRequest qualificationRequest, string token)
{
try
{
string request = JsonConvert.SerializeObject(qualificationRequest);
StringContent content = new StringContent(request, Encoding.UTF8, "application/json");
HttpClient client = new HttpClient
{
BaseAddress = new Uri(urlBase)
};
client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("bearer", token);
string url = $"{servicePrefix}{controller}";
HttpResponseMessage response = await client.PostAsync(url, content);
string result = await response.Content.ReadAsStringAsync();
if (!response.IsSuccessStatusCode)
{
return(new Response
{
IsSuccess = false,
Message = result,
});
}
ProductResponse product = JsonConvert.DeserializeObject <ProductResponse>(result);
return(new Response
{
IsSuccess = true,
Result = product
});
}
catch (Exception ex)
{
return(new Response
{
IsSuccess = false,
Message = ex.Message
});
}
}
