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(); }