public async Task <ProductOptions> GetOptions(Guid productId) { var options = new ProductOptions(); var product = await _productsContext.Products.FirstOrDefaultAsync(p => p.Id == productId); if (product == null) { throw new HttpResponseException(HttpStatusCode.NotFound); } var opt = product.ProductOptions .Where(p => p.ProductId == productId).ToList(); // throw if not options found if (!opt.Any()) { throw new HttpResponseException(HttpStatusCode.NotFound); } opt.ForEach(o => { options.Items.Add(TinyMapper.Map <ProductOption>(o)); }); return(options); }
//private readonly IStringLocalizer<ProductController> localizer; public ProductController(IProductRepository productRepository, IHubContext <ChatHub> hubContext, IOptionsMonitor <ProductOptions> productOptions) { this.productRepository = productRepository; this.hubContext = hubContext; this.productOptions = productOptions.CurrentValue; //localizer = localizer; }
public void SaveProductToCart(ProductOptions productOptions, OnRequestCompleteCallback onRequestComplete) { var _url = GameHiddenOptions.Instance.ServerURL + _urlPostCartProduct; Debug.Log(_url); byte[] pictureBytes = null; bool hasBytes = false; if (productOptions.picture_bytes != null) { hasBytes = true; pictureBytes = productOptions.picture_bytes; productOptions.picture_bytes = null; } var wwwForm = new WWWForm(); wwwForm.AddField("data", JsonUtility.ToJson(productOptions)); if (hasBytes) { wwwForm.AddBinaryData("picture_bytes", pictureBytes); } OnRequestComplete = onRequestComplete; StartCoroutine(WaitForRequest(_url, wwwForm)); }
public bool ProductsRemoveOption(Product p, string optionBvin) { Option opt = ProductOptions.Find(optionBvin); if (opt == null) { return(false); } bool result = ProductsXOptions.RemoveOptionFromProduct(p.Bvin, optionBvin); ProductsReloadOptions(p); // delete an option if it's not shared if (result) { if (!opt.IsShared) { result = ProductOptions.Delete(opt.Bvin); } } if (opt.IsVariant) { VariantsValidate(p); } return(result); }
public static IQueryable <Product> SearchProducts(ProductOptions productOptions, TinyCrmDbContext dbContext) { if (productOptions.PriceFrom != null && productOptions.PriceTo != null && productOptions.PriceFrom > productOptions.PriceTo) { return(null); } var query = dbContext.Set <Product>().AsQueryable(); if (productOptions.ProductId != null) { query = query.Where(p => p.ProductId == productOptions.ProductId); } if (productOptions.Categories != null && productOptions.Categories.Any()) { query = query.Where(p => productOptions.Categories.Contains(p.Category)); } if (productOptions.PriceFrom != null) { query = query.Where(p => p.Price >= productOptions.PriceFrom); } if (productOptions.PriceTo != null) { query = query.Where(p => p.Price <= productOptions.PriceTo); } query = query.Take(500); return(query); }
public void WillParsePackQuantity() { ProductOptions productOptionOne = new ProductOptions(); productOptionOne.display_name = "Material"; productOptionOne.display_value = "Brass"; ProductOptions productOptionTwo = new ProductOptions(); productOptionTwo.display_name = "Value Pack Options"; productOptionTwo.display_value = "4 Pack - $215.00 / Each - Best Value"; List <ProductOptions> productOptions = new List <ProductOptions>() { productOptionOne, productOptionTwo }; Product product = new Product(); product.ProductOptions = productOptions; int packQuantity = BigCommerceController.ParsePackQuantity(product); int expectedPackQuantity = 4; Assert.Equal(expectedPackQuantity, packQuantity); }
public async Task <List <Product> > GetProductsAsync(ProductOptions options) { List <Product> products; if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"[ProductRepository:GetProductsAsync] ProductOptions:{JsonConvert.SerializeObject(options)}"); } using (Amazon.DynamoDBv2.DataModel.IDynamoDBContext context = _factory.CreateContext()) { // TODO: Add filters - category and product id Amazon.DynamoDBv2.DataModel.AsyncSearch <Product> search = context.ScanAsync <Product>(null); products = await search.GetNextSetAsync(); } if (_logger.IsEnabled(LogLevel.Debug)) { _logger.LogDebug($"[ProductRepository:GetProductsAsync] Product:{JsonConvert.SerializeObject(products)}"); } return(products); }
public async Task <ProductOptions> GetAllAsync(Guid productId, Uri url, int limit, int offset) { var productOptions = new ProductOptions(); try { using (var context = new ProductContext()) { var query = context.ProductOptions.Where(p => p.ProductId == productId); var totalRecords = await query.CountAsync(); productOptions.Paging = new Paging(url, totalRecords, limit, offset); productOptions.Items = await query .OrderBy(p => p.Name) .Skip(productOptions.Paging.AdjustedOffset) .Take(limit) .ToListAsync(); } } catch (Exception ex) { _logger.Log(LogLevel.ERROR, "Error while retrieving all product options.", ex, new Dictionary <string, object> { { "requestUrl", url.AbsoluteUri } }); } return(productOptions); }
public IQueryable <Product> SearchProducts(ProductOptions opt) // search function { string optCustomerMinPrice = Convert.ToString(opt.MinPrice); string optCustomerMaxPrice = Convert.ToString(opt.MaxPrice); string optProductId = Convert.ToString(opt.ProductId); if (!(optProductId == "0")) { var queryId = db_ .Set <Product>() .AsQueryable(); queryId = queryId.Where(p => p.ProductId == opt.ProductId); return(queryId); } else { var query = db_ .Set <Product>() .AsQueryable(); if (!String.IsNullOrWhiteSpace(optCustomerMinPrice) && !String.IsNullOrWhiteSpace(optCustomerMaxPrice)) { query = query.Where(p => p.Price >= opt.MinPrice && p.Price <= opt.MaxPrice); query.Take(500); return(query); } return(query); } }
public ProductOptions GetOptions(Guid productId) { var productOptions = new ProductOptions { Items = _productOptionService.GetByProductId(productId).ToList() }; return(productOptions); }
public DictionaryService(IUnitOfWork unitOfWork, ILogger <DictionaryService> logger, IOptions <ProductOptions> option) { _unitOfWork = unitOfWork; _options = option.Value; _countItemsOnPage = _options.MaxCountOnPage; _logger = logger; _logger.LogInformation($"Read configuration MaxProductCountOnPage = {_countItemsOnPage}"); }
public Product GetProductById(string opt) // getproductbyid function { var po = new ProductOptions(); po.ProductId = opt; var product = SearchProducts(po).SingleOrDefault(); return(product); }
public async Task <IActionResult> GetAllOptionsAsync(Guid id) { Guard.Against.NullGuid(id, nameof(id)); IEnumerable <ProductOption> allProductOptions = await _productOptionsRepository.ListAsync(po => po.ProductId == id); var productOptions = new ProductOptions(allProductOptions); return(Ok(productOptions)); }
public async Task <ActionResult <ProductOptions> > RetrieveProductOptions(Guid id) { var productOptions = await productOptionService.RetrieveProductOptions(id); var productOptionCollection = new ProductOptions(); productOptionCollection.AddRange(productOptions); return(productOptionCollection); }
ProductOptions IProductService.CreateProduct(ProductOptions productOptions) { Product product = GetProductFromProductOptions(productOptions); dbContext.Products.Add(product); dbContext.SaveChanges(); productOptions.Id = product.Id; return(productOptions); }
public async Task <bool> DeleteProductOption(Guid productId, Guid optionId) { ProductOptions productOption = await GetOptionInDb(productId, optionId); _context.ProductOptions.Remove(productOption); var result = await _context.SaveChangesAsync(); return(result > 0 ? true : false); }
public ProductOptions LoadOptionsByProductId(Guid productId) { using (var conn = Helpers.NewConnection()) { string query = "SELECT * FROM ProductOption WHERE ProductId = @productId"; var result = conn.Query <ProductOption>(query, new { productId }); ProductOptions productOptions = new ProductOptions(result.ToList()); return(productOptions); } }
public void GetOptionsByProductId() { // Arrange var controller = new ProductsController(); // Act ProductOptions result = controller.GetOptions(getTestProductGuid()); // Assert Assert.IsNotNull(result); }
public ProductOptions GetProductOptionsForProduct(Guid productId) { var productOptionsEntity = _productOptionRepository.GetProductOptionsForProduct(productId); var mapper = GetMapper <ProductOption, Data.Entities.ProductOption>(); var productOptionsModel = new ProductOptions(); productOptionsEntity.ForEach(poe => { productOptionsModel.Items.Add(mapper.ToModel(poe)); }); return(productOptionsModel); }
private void Option_Click(object sender, RoutedEventArgs e) { var item = (ProductOptions)(sender as FrameworkElement).DataContext; var selectedOption = (RadioButton)((sender as FrameworkElement).Parent as FrameworkElement).FindName("SelectedOption"); selectedOption.IsChecked = true; _selectedProductOption = item; _optionPrice = item.Price; _defaultAdonPrice = item.ToppingPrice; GetPrice(); }
public void SaveProductOption(ProductOptionDetails productOptionDetails) { Product dbProduct = context.Product.Find(productOptionDetails.OptionProductId); ProductOptions dbProductOption = context.ProductOptions.Find(productOptionDetails.OptionId); if (dbProductOption == null) { dbProductOption = new ProductOptions(); dbProductOption.OptionId = productOptionDetails.OptionId; } dbProductOption.OptionName = productOptionDetails.OptionName; dbProductOption.OptionType = productOptionDetails.OptionType; dbProductOption.OptionProductId = productOptionDetails.OptionProductId; if (productOptionDetails.OptionParent is null) { dbProductOption.OptionParentId = null; } else { dbProductOption.OptionParentId = ProductOptions.Where(po => po.OptionName == productOptionDetails.OptionParent).Select(po => po.OptionId).FirstOrDefault(); } if (productOptionDetails.ParamCollection != null) { foreach (ProductOptionDetails.ProductOptionParamsDetails item in productOptionDetails.ParamCollection) { var parentOption = context.ProductOptions.Find(dbProductOption.OptionParentId); ProductOptionParams dbParam = context.ProductOptionParams.Find(item.ParameterId); if (dbParam == null) { dbParam = new ProductOptionParams(); dbParam.ParameterId = item.ParameterId; } dbParam.ParameterName = item.Paramname; dbParam.ParameterPrice = item.ParamPrice; dbParam.ParameterTooltip = item.ParamTooltip; dbParam.ParameterSale = item.Sale; dbParam.ParentOptionId = dbProductOption.OptionId; if (parentOption is null) { dbParam.ParameterParentId = null; } else { dbParam.ParameterParentId = parentOption.ProductOptionParams.Where(p => p.ParameterName == item.ParentParam).Select(p => p.ParameterId).FirstOrDefault(); } dbProductOption.ProductOptionParams.Add(dbParam); } } dbProduct.ProductOptions.Add(dbProductOption); }
public async Task ResumeAndPromptPlatformAsync(IDialogContext context, IAwaitable <ProductOptions> argument) { productOptions = await argument; PromptDialog.Choice( context: context, resume: ResumeAndPromptDescriptionAsync, options: Enum.GetValues(typeof(PlatformOptions)).Cast <PlatformOptions>().ToArray(), prompt: "Which platform did the problem occur on? (Linux, Mac, or Windows):", retry: "I didn't understand. Please try again."); }
private static Product GetProductFromProductOptions(ProductOptions productOptions) { return(new Product { Code = productOptions.Code, Description = productOptions.Description, Name = productOptions.Name, Price = productOptions.Price, Quantity = productOptions.Quantity, }); }
public async Task <IEnumerable <Product> > GetProducts(ProductOptions options) { IEnumerable <Product> products; var query = "SELECT * FROM Products"; using (IDbConnection connection = _connectionFactory.CreateConnection()) { products = await connection.QueryAsync <Product>(query); } return(products); }
public async Task <IEnumerable <Product> > GetAllAsync(ProductOptions options = null) { IEnumerable <Product> products = (options != null) ? await _repository.Products.FindAllWithProductLocationsAsync(options) : await _repository.Products.FindAllWithProductLocationsAsync(); // Calculate the product total stock products.ToList().ForEach(product => { product.Stock = product.ProductLocations?.Sum(x => x.Stock); }); return(products); }
public ProductOptions GetProductOptions(Guid productId) { if (productId == Guid.Empty) { throw new ArgumentNullException(nameof(productId)); } var optionsToReturn = _context.ProductOptions .Where(o => o.ProductId == productId) .OrderBy(o => o.Name).ToList() ?? new List <ProductOption>(); var optionsForProduct = new ProductOptions(optionsToReturn); return(optionsForProduct); }
public async Task <ActionResult <ProductOptionsDTO> > PostProductOptions( int inPrice, int inWeight, int inQuantity, int inProductID ) { Products prod = db.Products.FindAsync(inProductID).Result; if (prod == null) { return(new JsonResult(new { Status = "Error", Message = "No Product with the id of " + inProductID })); } ProductOptions productOptions = new ProductOptions { price = inPrice, weight = inWeight, quantity = inQuantity, ProductID = inProductID, created_at = DateTime.Now, updated_at = DateTime.Now, isAvailable = true, isDeleted = false, Product = prod }; try { db.ProductOptions.Add(productOptions); await db.SaveChangesAsync(); updateMaxMinPrice(productOptions.ProductID, productOptions.price); ProductOptionsDTO prodOptDTO = new ProductOptionsDTO { price = inPrice, weight = inWeight, quantity = inQuantity, ProductID = inProductID, created_at = DateTime.Now, updated_at = DateTime.Now, isAvailable = true, isDeleted = false }; return(prodOptDTO); } catch (Exception ex) { return(new JsonResult(new { Status = "Error", ex.Message })); }; }
public async Task <ViewProductOption> CreateProductOption(Guid productId, CreateProductOption createProductOption) { ProductOptions productOption = _mapper.Map <ProductOptions>(createProductOption); productOption.ProductId = productId; _context.Add <ProductOptions>(productOption); await _context.SaveChangesAsync(); var createdProductOption = _mapper.Map <ViewProductOption>(productOption); return(createdProductOption); }
public Product UpdateProduct(ProductOptions productOption, int id) { Product product = dbContext.Products.Find(id); product.Code = productOption.Code; product.Description = productOption.Description; product.Name = productOption.Name; product.Price = productOption.Price; product.Quantity = productOption.Quantity; dbContext.SaveChanges(); return(product); }
public void WillParsePersonalItemValueForPersonalItem() { ProductOptions productOption = new ProductOptions(); productOption.display_value = "1 Item - Personal Use - $129 / Each"; List <ProductOptions> productOptions = new List <ProductOptions>() { productOption }; bool isPersonal = BigCommerceController.isItemPersonal(productOptions); Assert.True(isPersonal); }