public ActionResult DeleteConfirmed(int id)
        {
            Pokedata pokedata = db.Pokedatas.Find(id);

            db.Pokedatas.Remove(pokedata);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
 public ActionResult Edit([Bind(Include = "PokemonId,DefaultImage,Name,Height,Weight")] Pokedata pokedata)
 {
     if (ModelState.IsValid)
     {
         db.Entry(pokedata).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(pokedata));
 }
        public ActionResult Create([Bind(Include = "PokemonId,DefaultImage,Name,Height,Weight")] Pokedata pokedata)
        {
            if (ModelState.IsValid)
            {
                db.Pokedatas.Add(pokedata);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(pokedata));
        }
        // GET: Pokedata/Edit/5
        public ActionResult Edit(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            Pokedata pokedata = db.Pokedatas.Find(id);

            if (pokedata == null)
            {
                return(HttpNotFound());
            }
            return(View(pokedata));
        }
        private static async Task <Pokedata> CreatePokemon(Task <string> fromUrl)
        {
            Pokedata pokeTask = await fromUrl.ContinueWith(s =>
            {
                PokemonContext db = new PokemonContext();
                JToken p          = JToken.Parse(s.Result);
                Pokedata poke     = new Pokedata
                {
                    PokemonId    = (int)p["id"],
                    DefaultImage = (string)p["sprites"]["front_default"],
                    Name         = (string)p["name"],
                    Height       = (int)p["height"],
                    Weight       = (int)p["weight"],

                    /*
                     * Moves = new JArray(p["moves"].Children()).Select(m => new Move  // May want to collect this from DBSet directly to collect existing entity. May cause duplication.
                     * {
                     *  MoveId = Utility.URLIndex((string)m["move"]["url"], true),
                     *  Name = (string)m["move"]["name"]
                     * }).ToList(),
                     *
                     * Abilities = new JArray(p["abilities"].Children()).Select(a => new Ability
                     * {
                     *  AbilityId = Utility.URLIndex((string)a["ability"]["url"], true),
                     *  Name = (string)a["ability"]["name"]
                     * }).ToList(),
                     */

                    Moves = new JArray(p["moves"].Children()).Select(m =>
                                                                     (Move)DBAttribute(db.Moves, m["move"])
                                                                     ).ToList(),
                    Abilities = new JArray(p["abilities"].Children()).Select(a =>
                                                                             (Ability)DBAttribute(db.Abilities, a["ability"])
                                                                             ).ToList(),
                };

                db.Dispose();
                return(poke);
            }, TaskScheduler.Default);

            return(pokeTask);
        }
        protected override void Seed(PokemonContext context)
        {
            /*
             * This is working and is significantly faster than previous attempts.
             *
             * Continuing with this pattern will lead to highly readable, yet
             * very repetitive code.
             *
             * TODO:
             *   - Implement attribute writes to DBContext as a function. Perform this in Parallel
             *     to allow for abilityDB and moveDB to run async.
             *   - Fill out the body of the application. Give it some personallity.
             *   - Look into VS 2017 event tracking. No longer provides accurate representation.
             */

            AggAbilities AbilList = new AggAbilities();

            foreach (Task <Ability> a in AbilList.AllAbilities)
            {
                a.ContinueWith(completed => {
                    switch (completed.Status)
                    {
                    case TaskStatus.RanToCompletion:
                        PokemonContext abilityDB = new PokemonContext();
                        abilityDB.Abilities.Add(completed.Result);
                        abilityDB.SaveChanges();
                        break;

                    case TaskStatus.Faulted: break;
                    }
                }, TaskScheduler.Default);
            }

            AggMoves MoveList = new AggMoves();

            foreach (Task <Move> m in MoveList.AllMoves)
            {
                m.ContinueWith(completed => {
                    switch (completed.Status)
                    {
                    case TaskStatus.RanToCompletion:
                        PokemonContext moveDB = new PokemonContext();
                        moveDB.Moves.Add(completed.Result);
                        moveDB.SaveChanges();
                        break;

                    case TaskStatus.Faulted: break;
                    }
                }, TaskScheduler.Default);
            }

            AggPokemon    PokeList  = new AggPokemon();
            TaskScheduler scheduler = new ConcurrentExclusiveSchedulerPair().ExclusiveScheduler;

            foreach (Task <Pokedata> p in PokeList.AllPokemon)
            {
                p.ContinueWith(completed => {
                    switch (completed.Status)
                    {
                    case TaskStatus.RanToCompletion:
                        PokemonContext pokemonDB = new PokemonContext();
                        Pokedata pokedata        = completed.Result;

                        foreach (Ability a in pokedata.Abilities)
                        {
                            pokemonDB.Abilities.Attach(a);
                        }

                        foreach (Move m in pokedata.Moves)
                        {
                            pokemonDB.Moves.Attach(m);
                        }

                        pokemonDB.Pokedatas.Add(pokedata);
                        pokemonDB.SaveChanges();

                        /*
                         * List<Ability> PokeAbils = pokedata.Abilities.ToList();
                         * pokedata.Abilities.Clear();
                         * List<Move> PokeMoves = pokedata.Moves.ToList();
                         * pokedata.Moves.Clear();
                         *
                         * pokemonDB.Pokedatas.Add(completed.Result);
                         * pokemonDB.SaveChanges();
                         *
                         * Pokedata currentPokemon = pokemonDB.Pokedatas.Find(pokedata.PokemonId);
                         *
                         * foreach (Ability a in PokeAbils)
                         * {
                         *  currentPokemon.Abilities.Add(a);
                         * }
                         *
                         * foreach (Move m in PokeMoves)
                         * {
                         *  currentPokemon.Moves.Add(m);
                         * }
                         */

                        break;

                    case TaskStatus.Faulted: break;
                    }
                }, scheduler);
            }
        }