public ActionResult Details(long id)
        {
            if (id != 0)
            {
                //Already Exist
                PlayersRepository modelRepo = new PlayersRepository();
                var model = modelRepo.ReadOne(id);

                //Create Player Premium Dashboard view bag only if Admin user is Logged in
                PlayerDashboardRepository pdRepo = new PlayerDashboardRepository();
                ViewBag.PlayerPremiumDashboard = pdRepo.ReadOne(model.PlayerID);

                if (Request.QueryString["m"] != null)
                {
                    List <MessagesExt> ListOfMsgs = new List <MessagesExt>();

                    new MessagesRepository().BuildMessageList(SecurityUtils.DecryptCypher(Request.QueryString["m"].ToString()), TypeOfMessage.Success, ref ListOfMsgs);

                    model.ListOfMsgs.AddRange(ListOfMsgs);
                }

                BindViewBags(ref model);
                return(View(model));
            }
            else
            {
                //For New Customer Record
                var model = new PlayersExt();
                model.PlayerID = 0;
                BindViewBags(ref model);
                return(View(model));
            }
        }
        public string ValidatePlayer_ForProgressImage(PlayersExt player, List <PlayerImagesExt> ListOfPlayerImages, long LeagueID, bool IsFront, bool IsSide)
        {
            DateTime TodayDate = DateTime.Now.Date.AddDays(2);

            string Msg = "";

            if (player == null)
            {
                Msg = "Your Email address is not valid OR it is not registered with MANvFAT Football";
            }
            else if (player.Active == false)
            {
                Msg = "Unable to upload your Photos, because your status is not Active in MANvFAT System";
            }
            else
            {
                if (ListOfPlayerImages.Count > 0)
                {
                    //if(ListOfPlayerImages.Any(m=> (m.UploadDateTime >= Last7Days && m.UploadDateTime <= TodayDate) && m.IsFront == IsFront))
                    if (ListOfPlayerImages.Any(m => (m.NextPhotoUploadDate.Date > TodayDate && m.UploadDateTime.Date <= TodayDate) && m.IsFront == IsFront && m.IsSide == false))
                    {
                        Msg = "Unable to upload your Photos, because you have already uploaded Front Image for this week";
                    }
                    else if (ListOfPlayerImages.Any(m => (m.NextPhotoUploadDate.Date > TodayDate && m.UploadDateTime.Date <= TodayDate) && m.IsSide == IsSide && m.IsFront == false))
                    {
                        Msg = "Unable to upload your Photos, because you have already uploaded Side Image for this week";
                    }
                }
            }

            return(Msg);
        }
        public ActionResult Registration(RegistrationExt model)
        {
            //Redirect the User to Error/RestrictedEmailDomain if user enter any Restricted Email Domain while Registration
            string _Msg    = "";
            bool   _status = true;

            if (ModelState.IsValid)
            {
                if (SecurityUtils.IsRestrictedEmailDomainDetected(model.EmailAddress))
                {
                    SecurityUtils.AddAuditLog("Restricted Email Address Detected", "Restricted Email Address: " + model.EmailAddress);

                    return(Json(new { status = false, Msg = "Restricted Email Address: " + model.EmailAddress }, JsonRequestBehavior.AllowGet));
                }

                PlayersExt        player     = MAP_Registration(model);
                PlayersRepository playerRepo = new PlayersRepository();
                playerRepo.CreateOrUpdate(ref player, ref _Msg, ref _status, this);


                return(Json(new { status = _status, Msg = _Msg }, JsonRequestBehavior.AllowGet));
            }

            foreach (ModelState modelState in ViewData.ModelState.Values)
            {
                foreach (ModelError error in modelState.Errors)
                {
                    _Msg = _Msg + " " + error.ErrorMessage;
                }
            }

            return(Json(new { status = false, Msg = _Msg }, JsonRequestBehavior.AllowGet));
        }
        public ActionResult NewIndex(RegistrationExt model)
        {
            //if (SecurityUtils.IsRestrictedEmailDomainDetected(model.EmailAddress))
            //{
            //    SecurityUtils.AddAuditLog("Restricted Email Address Detected", "Restricted Email Address: " + model.EmailAddress);

            //    return RedirectToAction("RestrictedEmailDomain", "Error");
            //}
            PlayersExt pModel = MAP_Registration(model);
            string     Msg    = "";
            bool       status = true;

            ModelState.Remove("id");
            pModel.Notes = "";
            PlayersRepository modelRepo = new PlayersRepository();

            pModel.PlayerID = modelRepo.CreateOrUpdate(ref pModel, ref Msg, ref status, this, false, 0);
            if (pModel.PlayerID > 0)
            {
                ViewBag.RegSuccess = true;
            }
            else
            {
                ViewBag.RegSuccess = false;
            }
            return(View());
        }
        public void BindViewBags(ref PlayersExt model)
        {
            //SystemSettingsRepository sysRepo = new SystemSettingsRepository();
            //var sys = sysRepo.GetSystemSettings();

            //string _EmergencyContactPageLink = sys.CurrentDomain + "/Home/EmergencyContact?p=" + EncryptedEmail;

            //model.EmergencyContactPageLink = _EmergencyContactPageLink;
        }
Exemple #6
0
        public bool SendEmail(PlayersExt player, string EncryptedRandomNum, string CurrentDomain)
        {
            string ResetPasswordLink = CurrentDomain + "/Member/ResetPassword/" + EncryptedRandomNum;

            MandrillRepository emailRepo = new MandrillRepository();
            bool status = true;

            status = emailRepo.SendForgottenPassword_Email(player, ResetPasswordLink);

            return(status);
        }
        public PlayersExt MAP_Registration(RegistrationExt RegExt)
        {
            PlayersExt model = new PlayersExt()
            {
                FirstName    = RegExt.FirstName,
                LastName     = RegExt.LastName,
                EmailAddress = RegExt.EmailAddress,
            };

            return(model);
        }
        public ActionResult Details(PlayersExt model)
        {
            List <MessagesExt> ListOfMsgs = new List <MessagesExt>();

            string Msg    = "";
            bool   status = true;

            ModelState.Remove("id");
            ModelState.Remove("PlayerTeamID");

            if (ModelState.IsValid)
            {
                try
                {
                    PlayersRepository modelRepo = new PlayersRepository();

                    if (model.PlayerID == 0)
                    {
                        var BMI = modelRepo.CalculateBMI(model.Weight, model.HeightID);
                        model.RegBMI = BMI;
                    }

                    model.PlayerID = modelRepo.CreateOrUpdate(ref model, ref Msg, ref status, this);
                    if (status)
                    {
                        if (model.IsApply)
                        {
                            System.Web.Routing.RouteValueDictionary rt = new System.Web.Routing.RouteValueDictionary();
                            rt.Add("id", model.PlayerID);
                            rt.Add("m", SecurityUtils.EncryptText(Msg));

                            return(RedirectToAction("Details", "Players", rt));
                        }
                        else
                        {
                            return(RedirectToAction("Index"));
                        }
                    }
                    else
                    {
                        ModelState.AddModelError("", Msg);
                        //BindViewBags(ref model);
                        //return View(model);
                    }
                }
                catch (Exception ex)
                {
                    string error = ErrorHandling.HandleException(ex);
                    ModelState.AddModelError("", error);
                    //BindViewBags(ref model);
                    //return View(model);
                }
            }

            {
                //Generate list of Error Messaged extracted from ModelState
                foreach (ModelState modelState in ViewData.ModelState.Values)
                {
                    foreach (ModelError error in modelState.Errors)
                    {
                        new MessagesRepository().BuildMessageList(error.ErrorMessage, TypeOfMessage.Error, ref ListOfMsgs);
                    }
                }

                model.ListOfMsgs.AddRange(ListOfMsgs);

                BindViewBags(ref model);

                return(View(model));
            }
        }