예제 #1
0
 public override async Task Execute(OrganismClassification model, OrganismDbContext _context)
 {
     _context.Remove(_context.Kingdoms.Include(i => i.Phylums)
                     .Single(i => i.KingdomTID == model.KingdomID).Phylums
                     .Single(i => i.PhylumTID == model.PhylumID));
     await _context.SaveChangesAsync();
 }
예제 #2
0
        //=INDEX===============================================================

        // GET: Organism
        public async Task <IActionResult> Index()
        {
            OrganismClassification OrganismC = new OrganismClassification();

            await TryUpdateModelAsync(OrganismC);

            ChosenTaxons viewModel = await ChosenTaxonsFiller.Fill(_context, OrganismC);

            return(View(viewModel));
        }
예제 #3
0
        // GET: Learning/AddSource/5
        public async Task <IActionResult> SourceIndex(int learningSetID)
        {
            OrganismClassification OrganismC = new OrganismClassification();

            await TryUpdateModelAsync(OrganismC);

            ChosenTaxons viewModel = await ChosenTaxonsFiller.Fill(_context, OrganismC);

            ViewBag.LearningSetID = learningSetID;
            return(View(viewModel));
        }
예제 #4
0
 public override async Task Execute(OrganismClassification model, OrganismDbContext _context)
 {
     _context.Remove(_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
                     .Single(i => i.FamilyTID == model.FamilyID));
     await _context.SaveChangesAsync();
 }
예제 #5
0
        public async Task Delete(OrganismClassification model, OrganismDbContext _context)
        {
            var action = typeof(DeleteBase).Assembly.GetTypes()
                         .Where(t => t.IsSubclassOf(typeof(DeleteBase)) && !t.IsAbstract)
                         .Select(t => (DeleteBase)Activator.CreateInstance(t))
                         .FirstOrDefault(a => a.ShouldExecute(model.Taxon));

            if (action == null)
            {
                throw new ArgumentException("Unknown case.");
            }

            await action.Execute(model, _context);
        }
예제 #6
0
        public async Task <IActionResult> DeleteConfirmed()
        {
            OrganismClassification organism = new OrganismClassification();

            if (await TryUpdateModelAsync(organism))
            {
                try
                {
                    await new DeleteStrategyContext().Delete(organism, _context);
                }
                catch (ArgumentException)
                {
                    return(NotFound());
                }
            }

            return(RedirectToAction("Index"));
        }
예제 #7
0
 public abstract Task Execute(OrganismClassification organism, OrganismDbContext _context);
예제 #8
0
        public static async Task <ChosenTaxons> Fill(OrganismDbContext _context, OrganismClassification OIDs)
        {
            ChosenTaxons viewModel = new ChosenTaxons
            {
                Kingdoms = await _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)
                           .OrderBy(i => i.Name)
                           .ToListAsync()
            };

            if (OIDs.KingdomID != null)
            {
                viewModel.ChosenKingdom = viewModel.Kingdoms
                                          .Single(x => x.KingdomTID == OIDs.KingdomID);
            }

            if (OIDs.PhylumID != null)
            {
                viewModel.ChosenPhylum = viewModel.ChosenKingdom.Phylums
                                         .Single(x => x.PhylumTID == OIDs.PhylumID);
            }

            if (OIDs.ClassID != null)
            {
                viewModel.ChosenClass = viewModel.ChosenPhylum.Classes
                                        .Single(x => x.ClassTID == OIDs.ClassID);
            }

            if (OIDs.OrderID != null)
            {
                viewModel.ChosenOrder = viewModel.ChosenClass.Orders
                                        .Single(x => x.OrderTID == OIDs.OrderID);
            }

            if (OIDs.FamilyID != null)
            {
                viewModel.ChosenFamily = viewModel.ChosenOrder.Families
                                         .Single(x => x.FamilyTID == OIDs.FamilyID);
            }

            if (OIDs.GenusID != null)
            {
                viewModel.ChosenGenus = viewModel.ChosenFamily.Genusses
                                        .Single(x => x.GenusTID == OIDs.GenusID);
            }

            if (OIDs.SpeciesID != null)
            {
                viewModel.ChosenSpecies = viewModel.ChosenGenus.Species
                                          .Single(x => x.SpeciesTID == OIDs.SpeciesID);
                await _context.Entry(viewModel.ChosenSpecies)
                .Collection(x => x.Imgs).LoadAsync();
            }

            return(viewModel);
        }