public ServiceResponse <ServiceProducts.Product> ArchiveProduct(int id)
{
var response = new ServiceResponse <ServiceProducts.Product>()
{
Time = DateTime.Now
};
try
{
var entityProduct = _productsReader.GetProductFromDbById(id);
_productsWriter.AddArchiveRecordToDb(entityProduct);
var serviceProduct = ProductMapper.SerialiseProduct(entityProduct);
response.Data = serviceProduct;
response.IsSuccessful = true;
response.Message = ($"Successfully archived {serviceProduct.Name}");
}
catch (Exception e)
{
response.IsSuccessful = false;
response.Message = ($"Could not archive product {response.Data.Name}. Stack trace: {e.StackTrace}");;
}
return(response);
}
/// <summary>
/// Creates/Updates a new product in database.
/// </summary>
/// <param name="userName">The current logged user name</param>
/// <param name="product">The ProductModel object to create</param>
/// <param name="isUpdate">Flag indicating if request comes from Update page</param>
/// <returns>Boolean indicating if record was created/updated</returns>
public bool CreateProduct(string userName, ProductModel product, bool isUpdate = false)
{
var entity = ProductMapper.MapProductModelToProductEntity(product);
var entities = new ProductManagerEntities1();
var existingProduct = entities.PRODUCTs.Find(product.Number);
var userEntity = entities.APPUSERs.Where(u => u.USERNAME == userName).ToList();
if (existingProduct == null && userEntity?.Count == 1)
{
entities.PRODUCTs.Add(entity);
entities.USERPRODUCTs.Add(new USERPRODUCT()
{
PRODUCT = entity, APPUSER = userEntity[0]
});
return(entities.SaveChanges() > 0);
}
else if (existingProduct != null && isUpdate)
{
existingProduct.TITLE = product.Title;
existingProduct.SKU = product.SKU;
existingProduct.PRICE = product.Price;
return(entities.SaveChanges() > 0);
}
return(false);
}
public void ToQuestionDtoList_ReturnsCorrectTypeAndNumberOfElements()
{
var choiceQuestion = TestQuestionFactory.ChoiceQuestion();
var numricQuestion = TestQuestionFactory.NumericQuestion();
var dateQuestion = TestQuestionFactory.DateQuestion();
var questions = new List <Question> {
choiceQuestion,
numricQuestion,
dateQuestion
};
var result = ProductMapper.ToQuestionDtoList(questions);
var resultChoiceQuestion = result?.First(r => r.QuestionCode == choiceQuestion.Code);
var resultNumericQuestion = result?.First(r => r.QuestionCode == numricQuestion.Code);
var resultDateQuestion = result?.First(r => r.QuestionCode == dateQuestion.Code);
Assert.NotNull(result);
Assert.NotEmpty(result);
Assert.Equal(questions.Count, result.Count);
Assert.NotNull(resultChoiceQuestion);
Assert.IsType <ChoiceQuestionDto>(resultChoiceQuestion);
Assert.NotNull(resultNumericQuestion);
Assert.IsType <NumericQuestionDto>(resultNumericQuestion);
Assert.NotNull(resultDateQuestion);
Assert.IsType <DateQuestionDto>(resultDateQuestion);
}
public async Task <IActionResult> Delete(int?id)
{
var product = await _context.Product
.SingleOrDefaultAsync(m => m.ID == id);
return(View(ProductMapper.MapProductToView(product)));
}
public void TestQueryProductWithCategoryId()
{
int categoryId = 6;
ProductMapper productMapper = new ProductMapper();
IList <Product> products = productMapper.FindProductsWithCategoryId(categoryId);
Assert.AreEqual(6, products.Count);
Assert.AreEqual(9, products[0].ProductID);
Assert.AreEqual("Mishi Kobe Niku", products[0].ProductName);
Assert.AreEqual(4, products[0].SupplierID);
Assert.AreEqual(6, products[0].CategoryID);
Assert.AreEqual("18 - 500 g pkgs.", products[0].QuantityPerUnit);
Assert.AreEqual(97.0000m, products[0].UnitPrice);
Assert.AreEqual((short)29, products[0].UnitsInStock);
Assert.AreEqual((short)0, products[0].UnitsOnOrder);
Assert.AreEqual((short)0, products[0].ReorderLevel);
Assert.AreEqual(true, products[0].Discontinued);
Assert.AreEqual(17, products[1].ProductID);
Assert.AreEqual(29, products[2].ProductID);
Assert.AreEqual(53, products[3].ProductID);
Assert.AreEqual(54, products[4].ProductID);
Assert.AreEqual(55, products[5].ProductID);
}
public ReceiptRepository()
{
receiptMapper = new ReceiptMapper();
productMapper = new ProductMapper();
categoryMapper = new CategoryMapper();
customizedProductService = new CustomizedProductService();
}
public void Save(Product product)
{
product.Id = Guid.NewGuid();
var entity = ProductMapper.MapToEntiy(product);
_productRepository.Add(entity);
}
private void btnAddProduct_Click(object sender, EventArgs e)
{
int i;
Product p = new Product();
p.Name = ProductName.Text;
p.Description = ProductNotes.Text;
p.RetailPrice = System.Convert.ToDecimal(ProductCost.Text);
p.ProductlID = ProductMapper.insertProduct(p);
foreach (var item in AddedMaterialsList.Items)
{
i = 0;
String temp = item.ToString();
MatchCollection v = Regex.Matches(temp, @"\d+");
foreach (Match match in v)
{
value = Int32.Parse(match.Value);
if (i == 0)
{
materialID = value;
}
else if (i == 1)
{
quantity = value;
}
i++;
}
Material m = new Material(materialID);
ProductMapper.addProductReqMaterial(p, m, quantity);
}
MessageBox.Show("New Product added");
this.Close();
}
public ServiceProducts.Product GetProductById(int id)
{
var entityProduct = _productsReader.GetProductFromDbById(id);
var serviceProduct = ProductMapper.SerialiseProduct(entityProduct);
return(serviceProduct);
}
public void TestInsertAndUpdateProductWithUoW()
{
Product product = new Product();
product.ProductName = "Test Product";
product.Discontinued = false;
MapperRegistry.Instance.Add(typeof(Product), ProductMapper.Instance);
ProductMapper mapper = (ProductMapper)MapperRegistry.Instance.Get(typeof(Product));
mapper.Add(product);
mapper.SaveChanges();
int productId = product.ProductID;
Product queriedProduct = mapper.FindProductById(productId);
Assert.AreEqual(product, queriedProduct);
queriedProduct.ProductName = "Updated Product";
queriedProduct.CategoryID = 1;
queriedProduct.Discontinued = true;
mapper.SaveChanges();
mapper.Remove(queriedProduct);
mapper.SaveChanges();
}
public static ProductModel GetProductById(Guid Id)
{
DBContext _context = new DBContext();
ProductModel product = ProductMapper.Mapper(_context.Products.Include(x => x.Skus).FirstOrDefault());
return(product);
}
public static List <ProductModel> GetAllProducts()
{
DBContext _context = new DBContext();
List <ProductModel> products = ProductMapper.Mapper(_context.Products.Include(x => x.Skus).ToList());
return(products);
}
// these are quite repetitive. How can I improve? Uncle Bob would say separate your error handling from method's logic
public ServiceResponse <ServiceProducts.Product> CreateProduct(ServiceProducts.Product productToAdd)
{
var now = DateTime.Now;
var response = new ServiceResponse <ServiceProducts.Product>()
{
Time = now
};
try
{
var entityProduct = ProductMapper.SerialiseProduct(productToAdd);
entityProduct.CreatedOn = now;
entityProduct.UpdatedOn = now;
_productsWriter.AddProductToDb(entityProduct);
CreateProductInventoryRecord(productToAdd);
response.IsSuccessful = true;
response.Message = ($"Successfully added {productToAdd.Name}");
response.Data = ProductMapper.SerialiseProduct(entityProduct);
}
catch (Exception e)
{
response.IsSuccessful = false;
response.Message = ($"Could not add {productToAdd.Name}. Stack trace: {e.StackTrace}");
response.Data = productToAdd;
}
return(response);
}
public ProductViewModel GetProduct(string productID)
{
DomainModel.Product product = productRepository.FindById(productID);
ProductViewModel productViewModel = ProductMapper.ToViewModel(product);
return(productViewModel);
}
public ProductService(IUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork;
_productMapper = new ProductMapper();
_deliveryTypeMapper = new DeliveryTypeMapper();
}
public async Task <ProductOptionDto> GetProductOptionAsync(Guid productId, Guid productOptionId)
{
var product = await _productRepository.GetAsync(productId);
var productOption = product.GetProductOption(productOptionId);
return(ProductMapper.GetProductOptionDto(productOption));
}
public ProductsController(IEntityBaseRepository <Product> productRepository,
IEntityBaseRepository <Error> errorRepository,
ProductMapper productMapper)
: base(errorRepository)
{
_productsRepository = productRepository;
_productMapper = productMapper;
}
public override async Task <List <Product> > AllAsync()
{
return(await RepositoryDbSet
.Include(r => r.RouteOfAdministration)
.Include(c => c.ProductClassification)
.Include(n => n.ProductName)
.Select(e => ProductMapper.MapFromDomain(e)).ToListAsync());
}
public IHttpActionResult GetProducts()
{
ICollection <ProductViewModel> products = _context.Products
.Where(x => x.IsDeleted == false).ToList()
.Select(x => ProductMapper.ProductViewModelMapper(x)).ToList();
return(Ok(products));
}
public HttpResponseMessage Post([FromBody] Product product)
{
var productModel = ProductMapper.MapToModel(product);
productSvc.Save(productModel);
return(Request.CreateResponse(HttpStatusCode.Created));
}
public ActionResult GetProduct()
{
_logger.LogInformation("Getting all products");
var products = _productService.GetAllProducts();
var productViewModel = products.Select(x => ProductMapper.SerializeProductModel(x));
return(Ok(productViewModel));
}
public MappingContext(string connectionStringName)
{
string connectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
clientMapper = new ClientMapper(connectionString);
productMapper = new ProductMapper(connectionString);
discountMapper = new DiscountMapper(connectionString);
discountPoliciesMapper = new DiscountPoliciesMapper(connectionString);
}
public async Task <ProductDto> GetProductByIdAsync(long id)
{
var product = await _productRepository.GetByIdAsync(id);
var result = ProductMapper.EntityToDtoMap(product);
return(result);
}
public ProductService(OrdersContext db,
ProductMapper productMapper,
OrderService orderService)
{
_db = db;
_productMapper = productMapper;
_orderService = orderService;
}
public IActionResult Delete(int id)
{
productContainer.Delete(id);
List <ProductViewModel> productViews = ProductMapper.AllProductViewModels();
return(RedirectToAction("Index", productViews));
}
public async Task <ProductDto> SearchProductAsync(string productName)
{
var product = await _productRepository.SearchAsync(productName);
var productDto = ProductMapper.GetProductDto(product);
return(productDto);
}
public void Handle_InvalidParam_Throws()
{
var mockRepository = new Mock <IRepository <ProductTypeFieldSourceMap, EntityFrameworkProductContext> >();
var productMapper = new ProductMapper(mockRepository.Object);
var productMessage = new ProductMessage();
Assert.Throws <NullReferenceException>(() => productMapper.Handle(productMessage));
}
public IActionResult Create()
{
var mappedEmployees = EmployeeMapper.MapManyToViewModel(employeeService.GetEmployees());
var mappedClients = ClientMapper.MapManyToViewModel(clientService.GetClients());
var mappedProducts = ProductMapper.MapManyToViewModel(productService.GetProducts());
return(View(new OrderCreateViewModel(mappedEmployees, mappedClients, mappedProducts)));
}
public async Task <IEnumerable <ProductDto> > Handle(ProductQueryGetAll request, CancellationToken cancellationToken)
{
var products = await _context.Products.ToListAsync();
var productDtos = ProductMapper.MapToDto(products);
return(productDtos);
}
public List <ProductImageDto> GetProductImages(int id)
{
var product = _productRepository.Get(id);
var productDto = ProductMapper.MapToDto(product);
return(productDto.Images);
}
public TransportService(IUnitOfWork unitOfWork)
{
_unitOfWork = unitOfWork;
_transportMapper = new TransportMapper();
_productMapper = new ProductMapper();
}
public void SetupContext()
{
this.mapper = new ProductMapper();
this.input=new StringReader("<product id='1' name='xyz' unitPrice='10.44' discontinued='true' />");
this.reader = XmlReader.Create(this.input);
while (this.reader.Read())
if (this.reader.Name == "product") return;
Assert.Fail("Expected product xml fragment not found.");
}
/// <summary>
/// Construct a new instance
/// </summary>
public CategoryProductsProvider(ApiProductsProvider apiProductsProvider, ProductMapper productMapper)
{
if (apiProductsProvider == null)
{
throw new ArgumentNullException("apiProductsProvider");
}
if (productMapper == null)
{
throw new ArgumentNullException("productMapper");
}
this.apiProductsProvider = apiProductsProvider;
this.productMapper = productMapper;
}
public void ProductMapperMapsToExpectedProperties()
{
// Arrange
var mapper = new ProductMapper();
var productDto = new ProductDto()
{
ID = "sp-001",
Price = 10m,
ProductName = "Super Product"
};
// Act
Product product = mapper.Map(productDto);
// Assert
Assert.AreEqual(10m, product.BasePrice);
Assert.AreEqual("sp-001", product.ID);
Assert.AreEqual("Super Product", product.Name);
}
/// <summary>
/// Construct a new instance
/// </summary>
public DomainsProvider(
IResellerDataProvider resellerDataProvider,
ICurrencyPreferenceProvider currencyPreferenceProvider,
ApiProductsProvider apiProductsProvider,
ProductMapper productMapper,
PublicBillingApiProxy billingApi,
IShopNameProvider shopNameProvider) : base(billingApi)
{
if (resellerDataProvider == null)
{
throw new ArgumentException("resellerDataProvider");
}
if (currencyPreferenceProvider == null)
{
throw new ArgumentException("currencyPreferenceProvider");
}
if (apiProductsProvider == null)
{
throw new ArgumentNullException("apiProductsProvider");
}
if (productMapper == null)
{
throw new ArgumentNullException("productMapper");
}
if (shopNameProvider == null)
{
throw new ArgumentNullException("shopNameProvider");
}
var resellerData = resellerDataProvider.GetResellerAccountData();
this.resellerId = resellerData.Id;
this.countryCode = resellerData.DefaultCountry.Code;
this.currencyCode = currencyPreferenceProvider.GetCurrentCurrency().Code;
this.productMapper = productMapper;
this.shopNameProvider = shopNameProvider;
this.tldProducts = apiProductsProvider.GetProductsByCategories(new List<string> { "TLD" });
}
public AssortmentRepository()
{
Mapper = new ProductMapper();
}
