public override async Task Execute(OrganismData model, OrganismDbContext _context)
{
SpeciesT oldSpecies = _context.Kingdoms
.Include(i => i.Phylums).ThenInclude(i => i.Classes).ThenInclude(i => i.Orders)
.ThenInclude(i => i.Families).ThenInclude(i => i.Genusses).ThenInclude(i => i.Species)
.Single(i => i.KingdomTID == model.KingdomID).Phylums
.Single(i => i.PhylumTID == model.PhylumID).Classes
.Single(i => i.ClassTID == model.ClassID).Orders
.Single(i => i.OrderTID == model.OrderID).Families
.Single(i => i.FamilyTID == model.FamilyID).Genusses
.Single(i => i.GenusTID == model.GenusID).Species
.Single(i => i.SpeciesTID == model.SpeciesID);
oldSpecies.Name = model.Name;
oldSpecies.Description = model.Description;
oldSpecies.Class = model.Class;
oldSpecies.Size = model.Size;
oldSpecies.Use = model.Use;
oldSpecies.OccurenceCR = model.OccurenceCR;
oldSpecies.Protection = model.Protection;
oldSpecies.EcoFunction = model.EcoFunction;
oldSpecies.Ecosystems = string.Join(", ", model.Ecosystems.Select(a => a.ToString()));
oldSpecies.OccurencesWorld = string.Join(", ", model.OccurencesWorld.Select(a => a.ToString()));
await _context.SaveChangesAsync();
}
public override async Task <int> Execute(OrganismData model, OrganismDbContext _context)
{
SpeciesT newSpecies = new SpeciesT()
{
Name = model.Name,
Description = model.Description,
Class = model.Class,
Classification = GetClassification(model, _context).Result,
Size = model.Size,
Use = model.Use,
OccurenceCR = model.OccurenceCR,
Protection = model.Protection,
EcoFunction = model.EcoFunction,
Ecosystems = string.Join(", ", model.Ecosystems.Select(a => a.ToString())),
OccurencesWorld = string.Join(", ", model.OccurencesWorld.Select(a => a.ToString()))
};
_context.Kingdoms
.Include(i => i.Phylums).ThenInclude(i => i.Classes).ThenInclude(i => i.Orders)
.ThenInclude(i => i.Families).ThenInclude(i => i.Genusses).ThenInclude(i => i.Species)
.Single(i => i.KingdomTID == model.KingdomID).Phylums
.Single(i => i.PhylumTID == model.PhylumID).Classes
.Single(i => i.ClassTID == model.ClassID).Orders
.Single(i => i.OrderTID == model.OrderID).Families
.Single(i => i.FamilyTID == model.FamilyID).Genusses
.Single(i => i.GenusTID == model.GenusID).Species
.Add(newSpecies);
await _context.SaveChangesAsync();
return(newSpecies.SpeciesTID);
}
public async Task <IActionResult> EditPost()
{
OrganismData organism = new OrganismData();
if (await TryUpdateModelAsync(organism))
{
try
{
await new EditStrategyContext().Edit(organism, _context);
}
catch (ArgumentException)
{
return(NotFound());
}
}
return(RedirectToAction("IndexImg", "Img",
routeValues: new
{
organism.KingdomID,
organism.PhylumID,
organism.ClassID,
organism.OrderID,
organism.FamilyID,
organism.GenusID,
organism.SpeciesID
}));
}
//=CREATE==============================================================
// GET: Organism/Create
public async Task <IActionResult> Create()
{
OrganismData Organism = new OrganismData();
await TryUpdateModelAsync(Organism);
return(View(Organism));
}
public override async Task Execute(OrganismData model, OrganismDbContext _context)
{
KingdomT oldKingdom = _context.Kingdoms
.Single(i => i.KingdomTID == model.KingdomID);
oldKingdom.Name = model.Name;
await _context.SaveChangesAsync();
}
public override async Task Execute(OrganismData model, OrganismDbContext _context)
{
PhylumT oldPhylum = _context.Kingdoms.Include(i => i.Phylums)
.Single(i => i.KingdomTID == model.KingdomID).Phylums
.Single(i => i.PhylumTID == model.PhylumID);
oldPhylum.Name = model.Name;
await _context.SaveChangesAsync();
}
//=EDIT================================================================
// GET: Organism/Edit/5
public async Task <IActionResult> Edit()
{
OrganismData viewModel = new OrganismData();
await TryUpdateModelAsync(viewModel);
viewModel = await OrganismDataFiller.Fill(_context, viewModel);
return(View(viewModel));
}
private async Task <string> GetClassification(OrganismData model, OrganismDbContext _context)
{
ChosenTaxons cht = await ChosenTaxonsFiller.Fill(_context, model);
return(cht.ChosenKingdom.Name + ", "
+ cht.ChosenPhylum.Name + ", "
+ cht.ChosenClass.Name + ", "
+ cht.ChosenOrder.Name + ", "
+ cht.ChosenFamily.Name + ", "
+ cht.ChosenGenus.Name);
}
public override async Task Execute(OrganismData model, OrganismDbContext _context)
{
OrderT oldOrder = _context.Kingdoms
.Include(i => i.Phylums).ThenInclude(i => i.Classes).ThenInclude(i => i.Orders)
.Single(i => i.KingdomTID == model.KingdomID).Phylums
.Single(i => i.PhylumTID == model.PhylumID).Classes
.Single(i => i.ClassTID == model.ClassID).Orders
.Single(i => i.OrderTID == model.OrderID);
oldOrder.Name = model.Name;
await _context.SaveChangesAsync();
}
public static async Task <OrganismData> Fill(OrganismDbContext _context, OrganismData viewModel)
{
ChosenTaxons taxons = await ChosenTaxonsFiller.Fill(_context, viewModel);
if (viewModel.KingdomID != null)
{
viewModel.Name = taxons.ChosenKingdom.Name;
}
if (viewModel.PhylumID != null)
{
viewModel.Name = taxons.ChosenPhylum.Name;
}
if (viewModel.ClassID != null)
{
viewModel.Name = taxons.ChosenClass.Name;
}
if (viewModel.OrderID != null)
{
viewModel.Name = taxons.ChosenOrder.Name;
}
if (viewModel.FamilyID != null)
{
viewModel.Name = taxons.ChosenFamily.Name;
}
if (viewModel.GenusID != null)
{
viewModel.Name = taxons.ChosenGenus.Name;
}
if (viewModel.SpeciesID != null)
{
viewModel.Name = taxons.ChosenSpecies.Name;
viewModel.Description = taxons.ChosenSpecies.Description;
viewModel.Class = taxons.ChosenSpecies.Class;
viewModel.Classification = taxons.ChosenSpecies.Classification;
viewModel.Size = taxons.ChosenSpecies.Size;
viewModel.Use = taxons.ChosenSpecies.Use;
viewModel.OccurenceCR = taxons.ChosenSpecies.OccurenceCR;
viewModel.Protection = taxons.ChosenSpecies.Protection;
viewModel.EcoFunction = taxons.ChosenSpecies.EcoFunction;
viewModel.Ecosystems = taxons.ChosenSpecies.Ecosystems.Split(", ")
.Select(x => (EcosystemEnum)Enum.Parse(typeof(EcosystemEnum), x)).ToArray();
viewModel.OccurencesWorld = taxons.ChosenSpecies.OccurencesWorld.Split(", ")
.Select(x => (OccurenceWorldEnum)Enum.Parse(typeof(OccurenceWorldEnum), x)).ToArray();
viewModel.Imgs = taxons.ChosenSpecies.Imgs;
}
return(viewModel);
}
public override async Task <int> Execute(OrganismData model, OrganismDbContext _context)
{
KingdomT newKingdom = new KingdomT
{
Name = model.Name
};
_context.Kingdoms.Add(newKingdom);
await _context.SaveChangesAsync();
return(newKingdom.KingdomTID);
}
public async Task Edit(OrganismData model, OrganismDbContext _context)
{
var action = typeof(EditBase).Assembly.GetTypes()
.Where(t => t.IsSubclassOf(typeof(EditBase)) && !t.IsAbstract)
.Select(t => (EditBase)Activator.CreateInstance(t))
.FirstOrDefault(a => a.ShouldExecute(model.Taxon));
if (action == null)
{
throw new ArgumentException("Unknown case.");
}
await action.Execute(model, _context);
}
public override async Task <int> Execute(OrganismData model, OrganismDbContext _context)
{
PhylumT newPhylum = new PhylumT()
{
Name = model.Name
};
_context.Kingdoms.Include(i => i.Phylums)
.Single(i => i.KingdomTID == model.KingdomID).Phylums
.Add(newPhylum);
await _context.SaveChangesAsync();
return(newPhylum.PhylumTID);
}
public override async Task <int> Execute(OrganismData model, OrganismDbContext _context)
{
ClassT newClass = new ClassT()
{
Name = model.Name
};
_context.Kingdoms
.Include(i => i.Phylums).ThenInclude(i => i.Classes)
.Single(i => i.KingdomTID == model.KingdomID).Phylums
.Single(i => i.PhylumTID == model.PhylumID).Classes
.Add(newClass);
await _context.SaveChangesAsync();
return(newClass.ClassTID);
}
public override async Task <int> Execute(OrganismData model, OrganismDbContext _context)
{
FamilyT newFamily = new FamilyT()
{
Name = model.Name
};
_context.Kingdoms
.Include(i => i.Phylums).ThenInclude(i => i.Classes).ThenInclude(i => i.Orders)
.ThenInclude(i => i.Families)
.Single(i => i.KingdomTID == model.KingdomID).Phylums
.Single(i => i.PhylumTID == model.PhylumID).Classes
.Single(i => i.ClassTID == model.ClassID).Orders
.Single(i => i.OrderTID == model.OrderID).Families
.Add(newFamily);
await _context.SaveChangesAsync();
return(newFamily.FamilyTID);
}
public async Task <IActionResult> CreatePost()
{
OrganismData organism = new OrganismData();
await TryUpdateModelAsync(organism);
try
{
int SpeciesID = await new CreateStrategyContext().Create(organism, _context);
if (organism.Taxon == "Druh")
{
return(RedirectToAction("IndexImg", "Img",
routeValues: new
{
organism.KingdomID,
organism.PhylumID,
organism.ClassID,
organism.OrderID,
organism.FamilyID,
organism.GenusID,
SpeciesID
}));
}
}
catch (ArgumentException)
{
return(NotFound());
}
return(RedirectToAction("Index",
routeValues: new
{
organism.KingdomID,
organism.PhylumID,
organism.ClassID,
organism.OrderID,
organism.FamilyID,
organism.GenusID,
organism.SpeciesID
}));
}
public abstract Task <int> Execute(OrganismData organism, OrganismDbContext _context);
