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