public ActionResult DeleteConfirmed(int id)
        {
            RankMaster rankMaster = db.RankMasters.Find(id);

            db.RankMasters.Remove(rankMaster);
            db.SaveChanges();
            return(RedirectToAction("Index"));
        }
 public ActionResult Edit([Bind(Include = "CustomerId,RankId,RankName,RankDescription,CreatedDate,IsDeleted")] RankMaster rankMaster)
 {
     if (ModelState.IsValid)
     {
         db.Entry(rankMaster).State = EntityState.Modified;
         db.SaveChanges();
         return(RedirectToAction("Index"));
     }
     return(View(rankMaster));
 }
        public ActionResult Create([Bind(Include = "CustomerId,RankId,RankName,RankDescription,CreatedDate,IsDeleted")] RankMaster rankMaster)
        {
            if (ModelState.IsValid)
            {
                db.RankMasters.Add(rankMaster);
                db.SaveChanges();
                return(RedirectToAction("Index"));
            }

            return(View(rankMaster));
        }
        // GET: RankMasters/Delete/5
        public ActionResult Delete(int?id)
        {
            if (id == null)
            {
                return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
            }
            RankMaster rankMaster = db.RankMasters.Find(id);

            if (rankMaster == null)
            {
                return(HttpNotFound());
            }
            return(View(rankMaster));
        }
Esempio n. 5
0
 public ActionResult Edit(RankMasterVM objrnkMstrVm)
 {
     try
     {
         using (var unitOfWork = new UnitWork1(new EAMSContext()))
         {
             var config = new MapperConfiguration(cfg =>
             {
                 cfg.CreateMap <RankMasterVM, RankMaster>();
             });
             IMapper    mapper    = config.CreateMapper();
             RankMaster UpdateDto = mapper.Map <RankMasterVM, RankMaster>(objrnkMstrVm);
             unitOfWork.RankMasters.Update(UpdateDto);
             unitOfWork.Complete();
             return(RedirectToAction("Index"));
         }
     }
     finally { }
 }
Esempio n. 6
0
        //  rank points are used to sort players
        public decimal RankPoints(NFLPlayer player, NFLGame game, NflTeam opponent)
        {
            decimal points = 0;

            #region short cut

            if (RankMaster.Contains(player.PlayerCode))
            {
                var rankedPlayer = ( NFLPlayer )RankMaster[player.PlayerCode];
                return(rankedPlayer.Points);
            }

            #endregion short cut

            #region Get the average output for the last 3 games

            //  Always start with the Average points in their last 3 games, if 0 and QB use 14
            if (game != null)
            {
                if (player.PlayerRole.Equals(Constants.K_ROLE_STARTER))
                {
                    var avgPoints = AveragePoints(player);

                    //  Rookies and injured players may not have played in the last 3 games
                    if (player.PlayerCat.Equals("1"))
                    {
                        if (avgPoints.Equals(0.0M))
                        {
                            avgPoints = 14.0M;                                                      // avergage for a QB
                        }
                    }
                    if (player.PlayerCat.Equals("2"))
                    {
                        if (avgPoints.Equals(0.0M))
                        {
                            avgPoints = 8.0M;                                                      // avergage for a RB
                        }
                    }
                    if (player.PlayerCat.Equals("3"))
                    {
                        if (avgPoints.Equals(0.0M))
                        {
                            avgPoints = 6.0M;                                                      // avergage for a RB
                        }
                    }
                    else if (player.PlayerCat.Equals("4"))
                    {
                        if (avgPoints.Equals(0.0M))
                        {
                            avgPoints = 6.0M;                                                      // avergage day for a PK
                        }
                    }
                    points += avgPoints;
                }
            }

            #endregion Get the average output for the last 3 games

            #region Consider the likely result

            decimal spreadModifier = 1;              //  no modification

            if (IncludeSpread)
            {
                if (game != null)
                {
                    spreadModifier = PlayerSpread(game.GetSpread(), game.IsHome(player.CurrTeam.TeamCode)) / 1;
                }

                points *= spreadModifier;
            }

            #endregion Consider the likely result

            #region factor in the quality of the opponent

            if (IncludeRatingModifier)
            {
                if (opponent != null)
                {
                    var oppRating      = player.OpponentRating(opponent.Ratings);
                    var ratingModifier = RatingModifier(oppRating);
                    points *= ratingModifier;
                }
            }

            #endregion factor in the quality of the opponent

            player.Points = points;
            RankMaster.Add(player.PlayerCode, player);               //  save points for later

#if DEBUG
            //  verbose audit trail of the calculations
            //Announce(string.Format(
            //   "{0,-16} has {1,4:#0.#} r pts- spr {2,4:#0.#} avgFP last 3 {3,4:##.#} rating mod {4,4:#0.#} {5}",
            //   player.PlayerNameShort, points, spreadModifier, avgPoints, ratingModifier, oppRating ) );
#endif
            return(points);
        }