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