// GET: Variant/Details/2
public ActionResult Details(int id)
{
UpdateVariant ViewModel = new UpdateVariant();
string url = "variantdata/findvariant/" + id;
HttpResponseMessage response = client.GetAsync(url).Result;
if (response.IsSuccessStatusCode)
{
//Variant goes in Data Transfer Object
VariantDto SelectedVariant = response.Content.ReadAsAsync <VariantDto>().Result;
ViewModel.variant = SelectedVariant;
//Find countries with this variant
url = "variantdata/getcountriesforvariant/" + id;
response = client.GetAsync(url).Result;
//Put data into Variant data transfer object
IEnumerable <CountryDto> SelectedCountries = response.Content.ReadAsAsync <IEnumerable <CountryDto> >().Result;
ViewModel.variantcountries = SelectedCountries;
return(View(ViewModel));
}
else
{
return(RedirectToAction("Error"));
}
}
public static Variant Convert(VariantDto item) =>
new Variant
{
Id = item.Id,
PollId = item.PollId,
Title = item.Title
};
public void AddVariant(VariantDto dto)
{
var variantDomain = new VariantDomain(this, dto);
Variants.Add(variantDomain);
AddIntegratedEvent(ProductEventType.VARIANT_ADDED, dto.Id);
Modify();
}
public void Update(VariantDto dto)
{
SetCode(dto.Code);
SetName(dto.Name);
SetDescription(dto.Description);
SetBasePrice(dto.BasePrice);
SetOptions(dto.Options);
SetImages(dto.Images);
}
public void UpdateVariant(VariantDomain variantDomain, VariantDto dto)
{
variantDomain.Update(dto);
if (variantDomain.Modified)
{
AddIntegratedEvent(ProductEventType.VARIANT_UPDATED, variantDomain.Id);
Modify();
}
}
public async Task <List <TaskItemDto> > GenerateDataLevelAsync(string userName)
{
var users = await GetUser(userName);
var userId = users.First().Id;
var levelList = await _unitOfWork.Repository <Word>().GetFilteredAsync(w => w.Level == Level && w.UserId == userId, "Translates");
var listWords = levelList.ToList();
var list = new List <TaskItemDto>();
var count = listWords.Count;
var rand = new Random(count);
var generatedCount = levelList.Count() >= MAX_GENERATE_LEVEL ? MAX_GENERATE_LEVEL : levelList.Count();
for (int i = 0; i < generatedCount; i++)
{
var newRand = rand.Next(count);
var word = listWords[newRand];
if (CheckIsTaskPresent(list, word))
{
i--;
continue;
}
var variants = new List <VariantDto>();
var listForVars = listWords.Where(w => w.Id != word.Id).ToList();
for (int j = 0; j < 4; j++)
{
var varNum = rand.Next(listForVars.Count - 1);
var wordVariant = listForVars[varNum];
var strvar = GetVariantText(wordVariant);
var varItem = new VariantDto()
{
Translation = strvar
};
variants.Add(varItem);
}
variants.Add(new VariantDto()
{
IsCorrect = true,
Translation = GetVariantText(word)
});
variants.Sort((var1, var2) => string.Compare(var1.Translation, var2.Translation, true));
list.Add(new TaskItemDto()
{
Origin = GetOriginalText(word),
Variants = variants,
Word = _mapper.Map <WordDto>(word)
});
}
return(list);
}
public VariantDomain(ProductDomain root, VariantDto dto)
{
Root = root;
Code = dto.Code;
Name = dto.Name;
Description = dto.Description;
BasePrice = dto.BasePrice;
Status = VariantStatus.ACTIVE;
SetOptions(dto.Options);
SetImages(dto.Images);
}
public static VariantViewModel CreateVariantVm(VariantDto variantDto, int itemId, int points, CourseViewModel courseVm)
{
return(new VariantViewModel
{
WisId = variantDto.Id,
WisItemId = itemId,
Title = variantDto.Title,
Points = points,
Limit = variantDto.Limit,
Reg = variantDto.Reg,
Course = courseVm
});
}
public ActionResult DeleteConfirm(int id)
{
string url = "variantdata/findvariant/" + id;
HttpResponseMessage response = client.GetAsync(url).Result;
//Debug.WriteLine(response.StatusCode);
if (response.IsSuccessStatusCode)
{
//Put data into Variant data transfer object
VariantDto SelectedVariant = response.Content.ReadAsAsync <VariantDto>().Result;
return(View(SelectedVariant));
}
else
{
return(RedirectToAction("Error"));
}
}
public IHttpActionResult GetVariants()
{
List <Variant> Variants = db.Variants.ToList();
List <VariantDto> VariantDtos = new List <VariantDto> {
};
foreach (var Variant in Variants)
{
VariantDto NewVariant = new VariantDto
{
VariantID = Variant.VariantID,
VariantName = Variant.VariantName
};
VariantDtos.Add(NewVariant);
}
return(Ok(VariantDtos));
}
public IHttpActionResult GetVariantsForCountry(int id)
{
List <Variant> Variants = db.Variants
.Where(s => s.Countries.Any(t => t.CountryID == id))
.ToList();
List <VariantDto> VariantDtos = new List <VariantDto> {
};
//Here you can choose which information is exposed to the API
foreach (var Variant in Variants)
{
VariantDto NewVariant = new VariantDto
{
VariantID = Variant.VariantID,
VariantName = Variant.VariantName
};
VariantDtos.Add(NewVariant);
}
return(Ok(VariantDtos));
}
public IHttpActionResult FindVariant(int id)
{
//Find the data
Variant Variant = db.Variants.Find(id);
//if not found, return 404 status code.
if (Variant == null)
{
return(NotFound());
}
//put into a 'friendly object format'
VariantDto VariantDto = new VariantDto
{
VariantID = Variant.VariantID,
VariantName = Variant.VariantName
};
//pass along data as 200 status code OK response
return(Ok(VariantDto));
}
public IProduct BuildFromProduct(StormProduct stormProduct)
{
var p = new ProductDto();
p.Category = new CategoryDto();
p.Category.ExternalId = stormProduct.CategoryId.ToString();
p.Manufacturer = new ManufacturerDto();
p.Manufacturer.Name = stormProduct.Manufacturer.Name;
p.Manufacturer.ExternalId = stormProduct.Manufacturer.Id.ToString();
p.Manufacturer.ImageUrl = stormProduct.Manufacturer.LogoKey;
p.ExternalId = stormProduct.Id.ToString();
p.PrimaryImageUrl = _configuration["Storm:ImagePrefix"] + stormProduct.ImageKey;
p.ShortDescription = stormProduct.SubDescription;
p.Description = stormProduct.Description;
p.Files = new List <IFile>();
// Add default image
FileDto primaryimagefile = new FileDto();
p.Files.Add(primaryimagefile);
primaryimagefile.ExternalId = stormProduct.ImageKey;
primaryimagefile.ImageUrl = _configuration["Storm:ImagePrefix"] + stormProduct.ImageKey;
primaryimagefile.Extension = "jpg";
primaryimagefile.Name = stormProduct.Image;
if (stormProduct.Files != null)
{
foreach (var stormfile in stormProduct.Files)
{
FileDto filedto = new FileDto();
p.Files.Add(filedto);
filedto.ExternalId = stormfile.Key;
filedto.ImageUrl = _configuration["Storm:ImagePrefix"] + stormfile.Key;
filedto.Extension = stormfile.Extension;
filedto.Name = stormfile.Name;
}
}
p.Values = new List <IAttributeValue>();
foreach (var parametric in stormProduct.Parametrics)
{
AttributeValueDto av = new AttributeValueDto();
av.Name = parametric.Name;
av.Code = parametric.Value2;
av.Value = parametric.Value;
av.ExternalId = parametric.Id.ToString();
av.Uom = parametric.Uom;
av.AttributeCode = parametric.ValueId.HasValue ? parametric.ValueId.Value.ToString() : string.Empty;
av.Hidden = parametric.IsHidden ?? false;
p.Values.Add(av);
}
p.Variants = new List <VariantDto>();
if (stormProduct.Variants == null || stormProduct.Variants.Length == 0)
{
var primaryVariant = new VariantDto();
p.Variants.Add(primaryVariant);
p.PrimaryVariant = primaryVariant;
decimal?previousPrice = null;
if (stormProduct.PriceStandard.HasValue && stormProduct.PriceStandard.Value > 0.0M)
{
previousPrice = stormProduct.PriceStandard.Value;
}
primaryVariant.PartNo = stormProduct.PartNo;
primaryVariant.PreviousPrice = previousPrice;
primaryVariant.Price = stormProduct.Price;
primaryVariant.PriceListId = stormProduct.PriceListId.ToString();
primaryVariant.VatRate = stormProduct.VatRate;
primaryVariant.VendorPartNo = stormProduct.Manufacturer.PartNo;
primaryVariant.VariantName = stormProduct.Name;
primaryVariant.ImageUrl = _configuration["Storm:ImagePrefix"] + stormProduct.ImageKey;
primaryVariant.AvailableToSell = 0.0M;
if (stormProduct.OnHand != null)
{
primaryVariant.AvailableToSell = stormProduct.OnHand.Value;
primaryVariant.LeadTime = stormProduct.OnHand.LeadtimeDayCount ?? 0;
}
if (stormProduct.OnHandSupplier != null)
{
if (primaryVariant.AvailableToSell == 0)
{
primaryVariant.LeadTime = stormProduct.OnHandSupplier.LeadtimeDayCount ?? 0;
}
primaryVariant.AvailableToSell += stormProduct.OnHandSupplier.Value;
}
if (stormProduct.IsBuyable)
{
primaryVariant.Buyable = _buyableExtension.Buyable(p, primaryVariant);
}
primaryVariant.StockStatus = _buyableExtension.StockStatus(p, primaryVariant);
}
else
{
foreach (var stormVariant in stormProduct.Variants)
{
var primaryVariant = new VariantDto();
p.Variants.Add(primaryVariant);
primaryVariant.PartNo = stormVariant.PartNo;
primaryVariant.PreviousPrice = stormVariant.PriceStandard;
primaryVariant.Price = stormVariant.Price;
primaryVariant.PriceListId = stormVariant.PriceListId.ToString();
primaryVariant.VatRate = stormVariant.VatRate;
//primaryVariant.VendorPartNo = stormVariant.Manufacturer.PartNo;
primaryVariant.VariantName = stormVariant.VariantName;
primaryVariant.ImageUrl = _configuration["Storm:ImagePrefix"] + stormVariant.ImageKey;
primaryVariant.AvailableToSell = 0.0M;
if (stormVariant.OnHand != null)
{
primaryVariant.AvailableToSell = stormVariant.OnHand.Value;
primaryVariant.LeadTime = stormVariant.OnHand.LeadtimeDayCount ?? 0;
}
if (stormVariant.OnHandSupplier != null)
{
if (primaryVariant.AvailableToSell == 0)
{
primaryVariant.LeadTime = stormVariant.OnHandSupplier.LeadtimeDayCount ?? 0;
}
primaryVariant.AvailableToSell += stormVariant.OnHandSupplier.Value;
}
if (stormProduct.IsBuyable)
{
primaryVariant.Buyable = _buyableExtension.Buyable(p, primaryVariant);
}
primaryVariant.StockStatus = _buyableExtension.StockStatus(p, primaryVariant);
}
p.PrimaryVariant = p.Variants[0];
}
return(p);
}
public IProduct BuildFromItem(StormProductItem stormProductItem)
{
var p = new ProductDto();
p.Category = new CategoryDto();
p.Category.ExternalId = stormProductItem.CategoryId.ToString();
p.GroupByKey = stormProductItem.GroupByKey;
p.Name = stormProductItem.Name;
p.Manufacturer = new ManufacturerDto();
p.Manufacturer.Name = stormProductItem.Manufacturer.Name;
p.Manufacturer.ExternalId = stormProductItem.Manufacturer.Id.ToString();
p.Manufacturer.ImageUrl = stormProductItem.Manufacturer.LogoKey;
p.ExternalId = stormProductItem.Id.ToString();
p.PrimaryImageUrl = _configuration["Storm:ImagePrefix"] + stormProductItem.ImageKey;
p.ShortDescription = stormProductItem.SubDescription;
p.Files = new List <IFile>();
p.Variants = new List <VariantDto>();
var primaryVariant = new VariantDto();
p.Variants.Add(primaryVariant);
p.PrimaryVariant = primaryVariant;
decimal?previousPrice = null;
if (stormProductItem.PriceStandard.HasValue && stormProductItem.PriceStandard.Value > 0.0M)
{
previousPrice = stormProductItem.PriceStandard.Value;
}
primaryVariant.PartNo = stormProductItem.PartNo;
primaryVariant.PreviousPrice = previousPrice;
primaryVariant.Price = stormProductItem.Price;
primaryVariant.PriceListId = stormProductItem.PriceListId.ToString();
primaryVariant.VatRate = stormProductItem.VatRate;
primaryVariant.VendorPartNo = stormProductItem.Manufacturer.PartNo;
primaryVariant.VariantName = stormProductItem.VariantName ?? stormProductItem.Name;
primaryVariant.Url = stormProductItem.VariantUniqueName ?? stormProductItem.UniqueName;
primaryVariant.ImageUrl = _configuration["Storm:ImagePrefix"] + (stormProductItem.VariantImageKey ?? stormProductItem.ImageKey);
primaryVariant.AvailableToSell = 0.0M;
if (stormProductItem.OnHand != null)
{
primaryVariant.AvailableToSell = stormProductItem.OnHand.Value;
primaryVariant.LeadTime = stormProductItem.OnHand.LeadtimeDayCount ?? 0;
}
if (stormProductItem.OnHandSupplier != null)
{
if (primaryVariant.AvailableToSell == 0)
{
primaryVariant.LeadTime = stormProductItem.OnHandSupplier.LeadtimeDayCount ?? 0;
}
primaryVariant.AvailableToSell += stormProductItem.OnHandSupplier.Value;
}
if (stormProductItem.IsBuyable)
{
primaryVariant.Buyable = _buyableExtension.Buyable(p, primaryVariant);
}
primaryVariant.StockStatus = _buyableExtension.StockStatus(p, primaryVariant);
return(p);
}
public static IGraph[] ConvertBack(VariantDto data)
{
return(data.Graphs
.Select(GraphToDtoConverter.ConvertBack)
.ToArray());
}
