private List <ProductVariantModel> GetVariants(Product product, ProductType productType, string culture) { var controls = FormControls.Controls().ToList(); var models = new List <ProductVariantModel>(); foreach (var variant in product.Variants) { var variantKey = new EntityKey(typeof(ProductVariant), variant.Id); var translation = _translationStore.Find(CultureInfo.GetCultureInfo(culture), variantKey); var model = new ProductVariantModel { Id = variant.Id, Sku = variant.Sku, Price = variant.Price }; foreach (var fieldDefinition in productType.VariantFieldDefinitions) { // field might be null because admin can add new fields to product types when products already exist var field = variant.VariantFields.FirstOrDefault(f => f.FieldName == fieldDefinition.Name); var control = controls.Find(c => c.Name == fieldDefinition.ControlType); var compared = new CustomFieldModel { FieldName = fieldDefinition.Name, FieldText = control.GetFieldDisplayText(fieldDefinition, field == null ? null : field.FieldValue), FieldValue = field == null ? null : field.FieldValue }; var translated = new CustomFieldModel { FieldName = compared.FieldName, FieldText = compared.FieldText, FieldValue = compared.FieldValue }; var diff = new CustomFieldModel { FieldName = compared.FieldName }; // If the field value is entered in product editing page, then it's always the field value that get translated if (translation != null && !control.IsSelectionList && !control.IsValuesPredefined) { translated.FieldText = translation.GetTranslatedText("VariantFields[" + fieldDefinition.Name + "]"); translated.FieldValue = translated.FieldText; diff.FieldText = DiffHelper.GetDiffHtml(translation.GetOriginalText("VariantFields[" + fieldDefinition.Name + "]"), field == null ? null : field.FieldValue); } model.VariantFields.Add(new TranslationTuple <CustomFieldModel>(compared, diff, translated)); } models.Add(model); } return(models); }
protected override void OnParametersSet() { base.OnParametersSet(); model = new ProductVariantModel(); context = new EditContext(model); editingEnabled = !Readonly; }
public ProductVariantModel CreateDefaultVariantModel(ProductType productType) { var variant = new ProductVariantModel(); foreach (var fieldDef in productType.VariantFieldDefinitions) { variant.VariantFields.Add(fieldDef.Name, null); } return(variant); }
public async Task UpdateProductVariant(Guid productId, Guid variantId, ProductVariantModel variant) { var url = UrlBuilder.UpdateProductVariantUrl(productId, variantId); var response = await Client.PutAsJsonAsync(url, variant); if (!response.IsSuccessStatusCode) { throw new ApplicationException($"Update variant {variantId} for product {productId} call ended with status code {response.StatusCode}"); } }
public async Task <IActionResult> PostVariant(Guid id, [FromBody] ProductVariantModel model) { if (id == Guid.Empty) { _logger.LogError("Empty product id"); return(BadRequest(nameof(id))); } await ControllerServices.AddProductVariant(id, model); _logger.LogInformation("Add variant to product {productId}", id); return(Ok()); }
private IEnumerable <PropertyTranslation> GetVariantTranslations(ProductVariantModel translatedVariant, ProductVariant originalVariant, ProductType productType, List <IFormControl> controls) { var translations = new List <PropertyTranslation>(); foreach (var definition in productType.VariantFieldDefinitions) { var field = translatedVariant.VariantFields.FirstOrDefault(f => f.Translated.FieldName == definition.Name); var control = controls.Find(c => c.Name == definition.ControlType); if (!control.IsSelectionList && !control.IsValuesPredefined) { var originalField = originalVariant.VariantFields.FirstOrDefault(f => f.FieldName == definition.Name); translations.Add(new PropertyTranslation("VariantFields[" + definition.Name + "]", originalField == null ? null : originalField.FieldValue, field.Translated.FieldValue)); } } return(translations); }
async Task RemoveVariant(ProductVariantModel variant) { try { await Client.DeleteProductVariant(_ProductId, variant.Id); variants.Remove(variant); } catch { errorRaised = true; } finally { StateHasChanged(); } }
public async Task <IActionResult> PutVariant(Guid id, Guid variantId, [FromBody] ProductVariantModel model) { if (id == Guid.Empty) { _logger.LogError("Empty product id"); return(BadRequest(nameof(id))); } if (variantId == Guid.Empty) { _logger.LogError("Empty variant id"); return(BadRequest(nameof(variantId))); } await ControllerServices.ChangeProductVariant(id, variantId, model); _logger.LogInformation("Variant {variantId} updated for product {productId}", variantId, id); return(Ok()); }
async Task SaveVariant(ProductVariantModel variant) { try { if (variant.Id == Guid.Empty) { await Client.CreateProductVariant(_ProductId, variant); await LoadVariants(); } else { await Client.UpdateProductVariant(_ProductId, variant.Id, variant); } } catch { errorRaised = true; } finally { StateHasChanged(); } }
public static ProductVariant ToEntity(this ProductVariantModel model, ProductVariant destination) { return(Mapper.Map(model, destination)); }
public static ProductVariant ToEntity(this ProductVariantModel model) { return(Mapper.Map <ProductVariantModel, ProductVariant>(model)); }
private void FirstVariant_PrepareProductVariantModel(ProductVariantModel model, ProductVariant variant, bool setPredefinedValues) { if (model == null) throw new ArgumentNullException("model"); //tax categories var taxCategories = _taxCategoryService.GetAllTaxCategories(); model.AvailableTaxCategories.Add(new SelectListItem() { Text = "---", Value = "0" }); foreach (var tc in taxCategories) model.AvailableTaxCategories.Add(new SelectListItem() { Text = tc.Name, Value = tc.Id.ToString(), Selected = variant != null && !setPredefinedValues && tc.Id == variant.TaxCategoryId }); model.PrimaryStoreCurrencyCode = _currencyService.GetCurrencyById(_currencySettings.PrimaryStoreCurrencyId).CurrencyCode; model.BaseWeightIn = _measureService.GetMeasureWeightById(_measureSettings.BaseWeightId).Name; model.BaseDimensionIn = _measureService.GetMeasureDimensionById(_measureSettings.BaseDimensionId).Name; if (setPredefinedValues) { model.MaximumCustomerEnteredPrice = 1000; model.MaxNumberOfDownloads = 10; model.RecurringCycleLength = 100; model.RecurringTotalCycles = 10; model.StockQuantity = 10000; model.NotifyAdminForQuantityBelow = 1; model.OrderMinimumQuantity = 1; model.OrderMaximumQuantity = 10000; model.DisplayOrder = 1; model.UnlimitedDownloads = true; model.IsShipEnabled = true; model.Published = true; } //little hack here in order to hide some of properties of the first product variant //we do it because they dublicate some properties of a product model.HideNameAndDescriptionProperties = true; model.HidePublishedProperty = true; model.HideDisplayOrderProperty = true; }
async Task RemoveVariant(ProductVariantModel variant) => await OnVariantRemoved.InvokeAsync(variant);
void EditVariant(ProductVariantModel variant) { model = variant; editingEnabled = true; }
void AddNewVariant() { model = new ProductVariantModel(); editingEnabled = true; }
public async Task AddProductVariant(Guid productId, ProductVariantModel model) => await Commands.AddProductVariant(productId, model.Name, model.EanCode, model.Sku, model.Price);
public async Task ChangeProductVariant(Guid productId, Guid variantId, ProductVariantModel model) => await Commands.ChangeProductVariant(productId, variantId, model.Name, model.EanCode, model.Sku, model.Price);
void Cancel() { model = new ProductVariantModel(); editingEnabled = false; }
private void FirstVariant_UpdateLocales(ProductVariant variant, ProductVariantModel model) { foreach (var localized in model.Locales) { _localizedEntityService.SaveLocalizedValue(variant, x => x.Name, localized.Name, localized.LanguageId); _localizedEntityService.SaveLocalizedValue(variant, x => x.Description, localized.Description, localized.LanguageId); } }
public async Task <IActionResult> GetVariants(int Id, int variantId) { var customModel1 = new List <customModel1>(); var productDetail = new ProductVariantModel(); var qry = from pvd in db.ProductVariantDetails where pvd.ProductId == Id && pvd.Id == variantId join pvo in db.ProductVariantOptions on pvd.Id equals pvo.ProductVariantDetailId join vo in db.VariantOptions on pvo.VariantOptionId equals vo.Id join v in db.Variants on vo.VariantId equals v.Id where pvd.IsActive == true && pvo.IsActive == true && vo.IsActive == true && v.IsActive == true select new customModel1 { VariantModel = v, VariantOption = vo, }; customModel1 = new List <customModel1>(); customModel1 = qry.Distinct().ToList(); var ProductVariantOption = await db.ProductVariantOptions.Where(c => c.IsActive == true && c.ProductVariantDetailId == variantId) .Select(m => new TestCore.ProductVariantOption { Id = m.Id, CategoryVariantId = m.CategoryVariantId, VariantOptionId = m.VariantOptionId, VariantOption = new VariantOptionModel { Id = m.VariantOption.Id, Name = m.VariantOption.Name, VariantId = m.VariantOption.VariantId, IsActive = m.VariantOption.IsActive, Variant = new VariantsModel { Id = m.VariantOption.Variant.Id, Name = m.VariantOption.Variant.Name, IsMain = m.VariantOption.Variant.IsMain, IsActive = m.VariantOption.Variant.IsActive, }, } }).ToListAsync(); var optionQry = from pvd in db.ProductVariantDetails where pvd.ProductId == Id && pvd.Id == variantId join pvo in db.ProductVariantOptions on pvd.Id equals pvo.ProductVariantDetailId join cv in db.CategoryVariants on pvo.CategoryVariantId equals cv.Id join v in db.Variants on cv.VariantId equals v.Id join vo in db.VariantOptions on v.Id equals vo.VariantId where pvd.IsActive == true && pvo.IsActive == true && cv.IsActive == true && v.IsActive == true select new customModel1 { VariantModel = v, VariantOption = vo }; var allOptions = new List <Variant>(); var variantData = await optionQry.Distinct().ToListAsync(); foreach (var item in variantData) { if (!allOptions.Any(c => c.Id == item.VariantModel.Id)) { allOptions.Add(item.VariantModel); } } var optionData = new List <VariantsModel>(); foreach (var varien in customModel1) { if (!productDetail.Variant.Any(x => x.Id == varien.VariantModel.Id)) { if (allOptions.Any(v => v.Id == varien.VariantModel.Id)) { var data = allOptions.Where(v => v.Id == varien.VariantModel.Id).Select(c => new VariantsModel { Id = c.Id, Name = c.Name, SelectedValue = varien.VariantOption.Id, IsMain = c.IsMain, VariantOptions = c.VariantOptions.Where(v => v.IsActive == true).Select(b => new VariantOption { Id = b.Id, Name = b.Name }).ToList() }).FirstOrDefault(); if (data.IsMain == true) { productDetail.Variant.Add(data); } else { if (!optionData.Any(c => c.Id == data.Id)) { optionData.Add(data); } } } } } var productVarientDetail = await db.ProductVariantDetails.Where(x => x.Id == variantId && x.IsActive == true) .Include(c => c.ProductVariantOptions).FirstOrDefaultAsync(); if (optionData.Count >= 0) { productDetail.Variant.AddRange(optionData); var options = productVarientDetail.ProductVariantOptions.Where(c => c.IsActive == true).ToList(); var otherDetail = db.ProductVariantDetails.Where(c => c.ProductId == productVarientDetail.ProductId && c.IsActive == true).Include(v => v.ProductVariantOptions) .ToList(); var data = new List <Models.ProductVariantOption>(); foreach (var op in otherDetail) { data.AddRange(op.ProductVariantOptions.Where(b => b.IsActive == true).ToList()); } int count = 0; int CategoryVariantId = 0; int optionId = 0; var ExtraVariant = new List <VariantModel>(); var variList = new List <VariantsModel>(); foreach (var item in productDetail.Variant) { if (count == 0) { if (options.Any(c => c.VariantOption.VariantId == item.Id)) { item.SelectedValue = options.Where(c => c.VariantOption.VariantId == item.Id).Select(v => v.VariantOptionId).FirstOrDefault(); CategoryVariantId = options.Where(c => c.VariantOption.VariantId == item.Id).Select(v => v.CategoryVariantId).FirstOrDefault(); optionId = item.SelectedValue; var listData = data.Where(c => c.VariantOption.Variant.Id == item.Id).ToList(); item.VariantOptions = new List <VariantOption>(); var opt = listData.Select(v => new VariantOption { Id = v.VariantOption.Id, Name = v.VariantOption.Name, }).ToList(); foreach (var op in opt) { if (!item.VariantOptions.Any(b => b.Id == op.Id)) { item.VariantOptions.Add(op); } } } } if (count >= 1) { var vari = new VariantsModel(); if (options.Any(c => c.VariantOption.VariantId == item.Id)) { item.SelectedValue = options.Where(c => c.VariantOption.VariantId == item.Id).Select(v => v.VariantOptionId).FirstOrDefault(); } var listData = data.Where(c => c.CategoryVariantId == CategoryVariantId && c.VariantOptionId == optionId && c.IsActive == true).ToList(); //----------change id according to previous variant option CategoryVariantId = options.Where(c => c.VariantOption.VariantId == item.Id).Select(v => v.CategoryVariantId).FirstOrDefault(); optionId = item.SelectedValue; var other = new List <Models.ProductVariantOption>(); foreach (var li in listData) { var p = data.Where(b => b.ProductVariantDetailId == li.ProductVariantDetailId).ToList(); if (p.Any(c => c.VariantOption.VariantId == item.Id)) { vari.Id = item.Id; vari.Name = item.Name; vari.SelectedValue = item.SelectedValue; var op = p.Where(b => b.VariantOption.VariantId == item.Id).Select(b => new VariantOption { Id = b.VariantOption.Id, Name = b.VariantOption.Name }).FirstOrDefault(); if (vari.VariantOptions == null) { vari.VariantOptions = new List <VariantOption>(); } if (!vari.VariantOptions.Any(b => b.Id == op.Id)) { vari.VariantOptions.Add(op); } } } variList.Add(vari); } count++; } int index = 0; foreach (var item in productDetail.Variant) { if (variList.Any(v => v.Id == item.Id) && index > 0) { item.VariantOptions = new List <VariantOption>(); item.VariantOptions = variList.Where(v => v.Id == item.Id).FirstOrDefault().VariantOptions; } index++; } } return(Ok(productDetail)); }