public async Task<IActionResult> Edit(int id, [Bind("ID,Name,Description,Price,ImageName")] ProductCore productCore) { if (id != productCore.ID) { return NotFound(); } if (ModelState.IsValid) { try { _context.Update(productCore); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ProductCoreExists(productCore.ID)) { return NotFound(); } else { throw; } } return RedirectToAction("Index"); } return View(productCore); }
public async Task<IActionResult> Create([Bind("ID,Name,Description,Price,ImageName")] ProductCore productCore) { if (ModelState.IsValid) { _context.Add(productCore); await _context.SaveChangesAsync(); return RedirectToAction("Index"); } return View(productCore); }
public HttpStatusCode Post(Product product) { ProductCore productCore = new ProductCore(); if (productCore.AddProduct(product) > 0) { return(HttpStatusCode.OK); } else { return(HttpStatusCode.InternalServerError); } }
public async Task <IHttpActionResult> Create([FromBody] Product product) { try { var response = await ProductCore.CreateAsync(product).ConfigureAwait(false); return(Ok(response)); } catch (Exception e) { LogHelper.LogException <ProductController>(e); return(Ok(ResponseFactory <Product> .CreateResponse(false, ResponseCode.Error))); } }
public HttpStatusCode Delete(int productId) { ProductCore productCore = new ProductCore(); Product product = new Product() { ProductID = productId }; if (productCore.RemoveProduct(product) > 0) { return(HttpStatusCode.OK); } else { return(HttpStatusCode.InternalServerError); } }
public void GetProductShouldReturnProduct() { IProductRepository productRepository = Substitute.For <IProductRepository>(); IBarCodeRepository codeRepository = Substitute.For <IBarCodeRepository>(); IInventoryItemCore inventoryCore = Substitute.For <IInventoryItemCore>(); IMapper mapper = Substitute.For <IMapper>(); string products = Data.ResourceManager.GetString("Products"); IEnumerable <Product> lstProducts = JsonConvert.DeserializeObject <IEnumerable <Product> >(products); productRepository.Find(1).Returns(lstProducts.First(lp => lp.Id == 1)); IProductCore controller = new ProductCore(productRepository, codeRepository, inventoryCore, mapper); var result = controller.Find(1); result.ProductId.Should().Be(1); }
public void GetProductsShouldReturnAllProducts() { IProductRepository productRepository = Substitute.For <IProductRepository>(); IBarCodeRepository codeRepository = Substitute.For <IBarCodeRepository>(); IInventoryItemCore inventoryCore = Substitute.For <IInventoryItemCore>(); IMapper mapper = Substitute.For <IMapper>(); string products = Data.ResourceManager.GetString("Products"); IEnumerable <Product> lstProducts = JsonConvert.DeserializeObject <IEnumerable <Product> >(products); productRepository.GetAll().Returns(lstProducts); IProductCore controller = new ProductCore(productRepository, codeRepository, inventoryCore, mapper); var result = controller.GetAll(); result.Should().HaveCount(4); }
public async Task <IHttpActionResult> GetAll() { try { var response = await ProductCore.GetAllAsync(new[] { nameof(Product.ValueAddedTax) }).ConfigureAwait(false); return(Ok(response)); } catch (Exception e) { LogHelper.LogException <ProductController>(e); return(Ok(ResponseFactory <IList <Product> > .CreateResponse(false, ResponseCode.Error))); } }
public async Task <IHttpActionResult> Get() { try { var productsResponse = await ProductCore.GetAllAsync().ConfigureAwait(false); var ordersResponse = await OrderCore.GetAllAsync().ConfigureAwait(false); var orderItemsResponse = await OrderItemCore.GetAllAsync().ConfigureAwait(false); var clientsResponse = await ClientCore.GetAllAsync().ConfigureAwait(false); var paymentsResponse = await PayrollCore.GetAllAsync().ConfigureAwait(false); if (!productsResponse.Success || !orderItemsResponse.Success || !orderItemsResponse.Success || !clientsResponse.Success || !paymentsResponse.Success) { return(Ok(ResponseFactory.CreateResponse(false, ResponseCode.Error))); } var totalIncomeValue = paymentsResponse.Data.Sum(payment => payment.Value); var totalOrdersValue = orderItemsResponse.Data.Sum(orderItem => orderItem.Price * orderItem.Quantity); var model = new SummaryModel { NumberOfClients = clientsResponse.Data.Count, NumberOfOrders = ordersResponse.Data.Count, NumberOfPayments = paymentsResponse.Data.Count, NumberOfProducts = productsResponse.Data.Count, TotalIncomeValue = totalIncomeValue, TotalOrdersValue = totalOrdersValue }; return(Ok(ResponseFactory <SummaryModel> .CreateResponse(true, ResponseCode.Success, model))); } catch (Exception e) { LogHelper.LogException <SummaryController>(e); return(Ok(ResponseFactory <SummaryModel> .CreateResponse(false, ResponseCode.Error))); } }
public void InitializeMockData() { try { Task.Run(async() => { var existingProducts = await ProductCore.GetAllAsync().ConfigureAwait(false); if (existingProducts.Data != null && existingProducts.Data.Count != 0) { return; } var products = await ProductCore.CreateAsync(mProducts, true).ConfigureAwait(false); var existingClients = await ClientCore.GetAllAsync().ConfigureAwait(false); if (existingClients.Data != null && existingClients.Data.Count != 0) { return; } var currencies = await CurrencyCore.GetAllAsync().ConfigureAwait(false); if (!currencies.Success || currencies.Data == null || currencies.Data.Count == 0) { return; } var currency = currencies.Data.FirstOrDefault(c => c.Name == "RON"); if (currency == null) { return; } foreach (var client in mClients) { client.CurrencyId = currency.Id; } var clients = await ClientCore.CreateAsync(mClients, true).ConfigureAwait(false); var existingOrders = await OrderCore.GetAllAsync().ConfigureAwait(false); if (existingOrders.Data != null && existingOrders.Data.Count != 0) { return; } int nr = 0; List <Order> newOrders = new List <Order>(); foreach (var client in clients.Data) { if (products.Data.Count >= 6) { for (int i = 0; i < 2; i++) { nr++; var o = new Order() { Id = Guid.NewGuid(), CurrencyId = currency.Id, ClientId = client.Id, SaleType = i, Status = 0, Date = DateTime.Now.AddDays(-nr).AddHours(-nr), OrderItems = new List <OrderItem>() }; for (int k = i + nr / 2; k < 6; k += 1) { o.OrderItems.Add(new OrderItem() { Id = Guid.NewGuid(), OrderId = o.Id, ProductId = products.Data.ElementAt(k).Id, Price = products.Data.ElementAt(k).Price, Quantity = k + 1 }); } newOrders.Add(o); } } } var orders = await OrderCore.CreateAsync(newOrders, true, new[] { nameof(Order.OrderItems) }).ConfigureAwait(false); var payrolls = new List <Payroll>(); if (orders.Data.Count > 3) { for (int i = 0; i < 3; i++) { var payroll = new Payroll() { Id = Guid.NewGuid(), ClientId = clients.Data.ElementAt(i).Id, OrderId = orders.Data.ElementAt(i).Id, Date = DateTime.Now.AddDays(-i), Value = orders.Data.ElementAt(i).OrderItems.Sum(p => p.Price * p.Quantity), }; payrolls.Add(payroll); } } await PayrollCore.CreateAsync(payrolls, true).ConfigureAwait(false); }).ConfigureAwait(false).GetAwaiter().GetResult(); } catch (Exception ex) { // ignored } }
public override async Task ProcessActivityAsync(IStatus status) { var updateDownloadsTask = await statusController.CreateAsync( status, $"Update {context} downloads"); var getSourcesTask = await statusController.CreateAsync( updateDownloadsTask, $"Get {context} download sources"); var downloadSources = await getDownloadSourcesAsyncDelegate.GetDownloadSourcesAsync(getSourcesTask); await statusController.CompleteAsync(getSourcesTask); var counter = 0; foreach (var downloadSource in downloadSources) { // don't perform expensive updates if there are no actual sources if (downloadSource.Value != null && downloadSource.Value.Count == 0) { continue; } var id = downloadSource.Key; ProductCore product = await productsDataController.GetByIdAsync(id, updateDownloadsTask); if (product == null) { product = await accountProductsDataController.GetByIdAsync(id, updateDownloadsTask); if (product == null) { await statusController.WarnAsync( updateDownloadsTask, $"Downloads are scheduled for the product/account product {id} that doesn't exist"); continue; } } await statusController.UpdateProgressAsync( updateDownloadsTask, ++counter, downloadSources.Count, product.Title); var productDownloads = await productDownloadsDataController.GetByIdAsync(product.Id, updateDownloadsTask); if (productDownloads == null) { productDownloads = new ProductDownloads { Id = product.Id, Title = product.Title, Downloads = new List <ProductDownloadEntry>() }; } // purge existing downloads for this download type as we'll always be scheduling all files we need to download // and don't want to carry over any previously scheduled files that might not be relevant anymore // (e.g. files that were scheduled, but never downloaded and then removed from data files) var existingDownloadsOfType = productDownloads.Downloads.FindAll( d => d.Context == context).ToArray(); foreach (var download in existingDownloadsOfType) { productDownloads.Downloads.Remove(download); } var scheduleDownloadsTask = await statusController.CreateAsync( updateDownloadsTask, "Schedule new downloads"); foreach (var source in downloadSource.Value) { var destinationDirectory = getDirectoryDelegate?.GetDirectory(source); var scheduledDownloadEntry = new ProductDownloadEntry { Context = context, SourceUri = source, Destination = destinationDirectory }; var destinationUri = Path.Combine( destinationDirectory, Path.GetFileName(source)); // we won't schedule downloads for the already existing files // we won't be able to resolve filename for productFiles, but that should cut off // number of images we constantly try to redownload if (fileController.Exists(destinationUri)) { continue; } productDownloads.Downloads.Add(scheduledDownloadEntry); } await productDownloadsDataController.UpdateAsync(productDownloads, scheduleDownloadsTask); await statusController.CompleteAsync(scheduleDownloadsTask); } await statusController.CompleteAsync(updateDownloadsTask); }
public IEnumerable <Product> Get(string id) { ProductCore productCore = new ProductCore(); return(productCore.GetProductsFacade(ProductAction.GetProductsForProductTypeID, id)); }
public IEnumerable <Product> Get() { ProductCore productCore = new ProductCore(); return(productCore.GetProductsFacade(ProductAction.GetAllProducts).ToList <Product>()); }
public string Get(int id) { ProductCore productCore = new ProductCore(); return(productCore.GetPrice(id)); }
public async Task <ProductCore> Update(ProductCore entity) { return(_mapper.Map <ProductCore>(await _repository.Update(_mapper.Map <Product>(entity)))); }
public async Task Delete(ProductCore entity) { await _repository.Delete(_mapper.Map <Product>(entity)); }