Exemplo n.º 1
0
        private DO.UIUserLogin LoadDataForLogin(DO.UIUserLogin objUIUserLogin)
        {
            try
            {
                if (objUIUserLogin.UserSkills != null && objUIUserLogin.UserSkills.Count > 0)
                {
                    List <DOCMN_LookupMaster> lstAllDOCMN_LookupMaster = CacheUtility.GetAllLookupsFromCache(null);
                    List <DOCMN_LookupMaster> lstDOCMN_LookupMaster;


                    List <UserSkills> Correlations = objUIUserLogin.UserSkills.GroupBy(x => new { x.BusinessSegmentLkup, x.WorkBasketLkup, x.RoleLkup }).Select(x => x.First()).ToList();
                    objUIUserLogin.Correlations = Correlations;

                    lstDOCMN_LookupMaster = new List <DOCMN_LookupMaster>();
                    //Business Segment
                    Correlations.Select(x => x.BusinessSegmentLkup).Distinct().ToList().ForEach(BusinessSegmentId =>
                    {
                        if (BusinessSegmentId > 0)
                        {
                            lstDOCMN_LookupMaster.Add(lstAllDOCMN_LookupMaster.Where(x => x.CMN_LookupMasterId.Equals(BusinessSegmentId)).FirstOrDefault());
                        }
                    });
                    //Work Basket
                    Correlations.Select(x => x.WorkBasketLkup).Distinct().ToList().ForEach(WorkBasketId =>
                    {
                        if (WorkBasketId > 0)
                        {
                            lstDOCMN_LookupMaster.Add(lstAllDOCMN_LookupMaster.Where(x => x.CMN_LookupMasterId.Equals(WorkBasketId)).FirstOrDefault());
                        }
                    });
                    //Role
                    Correlations.Select(x => x.RoleLkup).Distinct().ToList().ForEach(RoleId =>
                    {
                        if (RoleId > 0)
                        {
                            lstDOCMN_LookupMaster.Add(lstAllDOCMN_LookupMaster.Where(x => x.CMN_LookupMasterId.Equals(RoleId)).FirstOrDefault());
                        }
                    });
                    objUIUserLogin.LookUps = lstDOCMN_LookupMaster;
                }
                if (objUIUserLogin.ADM_UserPreference != null)
                {
                    objUIUserLogin.BusinessSegmentLkup = objUIUserLogin.ADM_UserPreference.BusinessSegmentLkup;
                    objUIUserLogin.WorkBasketLkup      = objUIUserLogin.ADM_UserPreference.WorkBasketLkup;
                    objUIUserLogin.RoleLkup            = objUIUserLogin.ADM_UserPreference.RoleLkup;
                }
            }
            catch (Exception ex)
            {
                BLCommon.LogError(0, MethodBase.GetCurrentMethod().Name, (long)ErrorModuleName.Login, (long)ExceptionTypes.Uncategorized, string.Empty, ex.ToString());
            }
            return(objUIUserLogin);
        }
Exemplo n.º 2
0
        public ActionResult Login(long BusinessSegmentLkup = 0, long WorkBasketLkup = 0, long RoleLkup = 0)
        {
            try
            {
                ReLogin : string s = string.Empty;
                if (BusinessSegmentLkup > 0 && WorkBasketLkup > 0 && RoleLkup > 0)
                {
                    string[] strLoginName = System.Web.HttpContext.Current.User.Identity.Name.Split(new string[] { @"\" }, StringSplitOptions.RemoveEmptyEntries);
                    string   domain       = strLoginName[0];
                    string   loginName    = strLoginName[1];

                    if (Session[ConstantTexts.UserSessionBeforeLoginKey] != null)
                    {
                        DO.UIUserLogin loggedInUser = (DO.UIUserLogin)Session[ConstantTexts.UserSessionBeforeLoginKey];

                        loggedInUser.WorkBasketLkup      = WorkBasketLkup;
                        loggedInUser.BusinessSegmentLkup = BusinessSegmentLkup;
                        loggedInUser.RoleLkup            = RoleLkup;

                        bool   IsADGroupAssigned         = true;
                        string WorkBasletADGroupRequired = "";
                        string RoleADGroupRequired       = "";

                        //check if user has AD group access to slected Role and Workbasket
                        switch (RoleLkup)
                        {
                        case (long)Utility.RoleLkup.Admin:
                            RoleADGroupRequired = Utility.RoleLkup.Admin.ToString();
                            switch (WorkBasketLkup)
                            {
                            case (long)Utility.WorkBasket.GPSvsMMR:
                                IsADGroupAssigned         = loggedInUser.IsAdmEligUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.GPSvsMMR.ToString();
                                break;

                            case (long)Utility.WorkBasket.OST:
                                IsADGroupAssigned         = loggedInUser.IsAdmOSTUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.OST.ToString();
                                break;

                            case (long)Utility.WorkBasket.RPR:
                                IsADGroupAssigned         = loggedInUser.IsAdmRPRUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.RPR.ToString();
                                break;
                            }
                            break;

                        case (long)Utility.RoleLkup.Processor:
                            RoleADGroupRequired = Utility.RoleLkup.Processor.ToString();
                            switch (WorkBasketLkup)
                            {
                            case (long)Utility.WorkBasket.GPSvsMMR:
                                IsADGroupAssigned         = loggedInUser.IsPrcrEligUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.GPSvsMMR.ToString();
                                break;

                            case (long)Utility.WorkBasket.OST:
                                IsADGroupAssigned         = loggedInUser.IsPrcrOSTUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.OST.ToString();
                                break;

                            case (long)Utility.WorkBasket.RPR:
                                IsADGroupAssigned         = loggedInUser.IsPrcrRPRUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.RPR.ToString();
                                break;
                            }
                            break;

                        case (long)Utility.RoleLkup.Manager:
                            RoleADGroupRequired = Utility.RoleLkup.Manager.ToString();
                            switch (WorkBasketLkup)
                            {
                            case (long)Utility.WorkBasket.GPSvsMMR:
                                IsADGroupAssigned         = loggedInUser.IsMgrEligUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.GPSvsMMR.ToString();
                                break;

                            case (long)Utility.WorkBasket.OST:
                                IsADGroupAssigned         = loggedInUser.IsMgrOSTUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.OST.ToString();
                                break;

                            case (long)Utility.WorkBasket.RPR:
                                IsADGroupAssigned         = loggedInUser.IsMgrRPRUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.RPR.ToString();
                                break;
                            }
                            break;

                        case (long)Utility.RoleLkup.Viewer:
                            RoleADGroupRequired = Utility.RoleLkup.Viewer.ToString();
                            switch (WorkBasketLkup)
                            {
                            case (long)Utility.WorkBasket.GPSvsMMR:
                                IsADGroupAssigned         = loggedInUser.IsVwrEligUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.GPSvsMMR.ToString();
                                break;

                            case (long)Utility.WorkBasket.OST:
                                IsADGroupAssigned         = loggedInUser.IsVwrOSTUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.OST.ToString();
                                break;

                            case (long)Utility.WorkBasket.RPR:
                                IsADGroupAssigned         = loggedInUser.IsVwrRPRUser;
                                WorkBasletADGroupRequired = Utility.WorkBasket.RPR.ToString();
                                break;
                            }
                            break;
                        }

                        if (!IsADGroupAssigned)
                        {
                            //If no AD group Access return error message
                            loggedInUser.ErrorMessage = string.Format(ConstantTexts.NotPartofADgroupForRoleError, RoleADGroupRequired, WorkBasletADGroupRequired);
                            return(View(loggedInUser));
                        }

                        BLUserAdministration objBLUserAdministration = new BLUserAdministration();
                        ExceptionTypes       result = objBLUserAdministration.LoginUser(loginName);
                        if (result != (long)ExceptionTypes.Success)
                        {
                            loggedInUser.ErrorMessage = ConstantTexts.LoginException;
                            return(View(loggedInUser));
                        }

                        //filter skills for slected workbasket and roles
                        loggedInUser.UserSkills = loggedInUser.UserSkills.Where(x => x.WorkBasketLkup.Equals(WorkBasketLkup) && x.RoleLkup.Equals(RoleLkup)).ToList();

                        //Filter Queues avalaible to user in current access group
                        loggedInUser.UserQueueList = (from UQL in loggedInUser.UserQueueList
                                                      join US in loggedInUser.UserSkills on UQL.QueueLkp equals US.WorkQueuesLkup
                                                      where US.WorkQueuesLkup > 0
                                                      select UQL).GroupBy(x => x.QueueLkp).Select(y => y.FirstOrDefault()).ToList();

                        //Set Menu Visibilities
                        switch (WorkBasketLkup)
                        {
                        case (long)WorkBasket.GPSvsMMR:
                            loggedInUser.IsMMREligibilityMenuVisible = loggedInUser.UserSkills.Any(x => x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.Eligibility);
                            if (loggedInUser.IsMMREligibilityMenuVisible)
                            {
                                loggedInUser.EligibilityMMRCanCreate = loggedInUser.UserSkills.Any(x => x.CanCreate && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.Eligibility);
                                loggedInUser.EligibilityMMRCanSearch = loggedInUser.UserSkills.Any(x => x.CanSearch && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.Eligibility);
                            }
                            loggedInUser.IsDOBMenuVisible = loggedInUser.UserSkills.Any(x => x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.DOB);
                            if (loggedInUser.IsDOBMenuVisible)
                            {
                                loggedInUser.EligibilityDOBCanCreate = loggedInUser.UserSkills.Any(x => x.CanCreate && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.DOB);
                                loggedInUser.EligibilityDOBCanSearch = loggedInUser.UserSkills.Any(x => x.CanSearch && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.DOB);
                            }
                            loggedInUser.IsGENDERMenuVisible = loggedInUser.UserSkills.Any(x => x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.Gender);
                            if (loggedInUser.IsGENDERMenuVisible)
                            {
                                loggedInUser.EligibilityGenderCanCreate = loggedInUser.UserSkills.Any(x => x.CanCreate && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.Gender);
                                loggedInUser.EligibilityGenderCanSearch = loggedInUser.UserSkills.Any(x => x.CanSearch && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.Gender);
                            }
                            break;

                        case (long)WorkBasket.OST:
                            loggedInUser.IsOOAMenuVisible = loggedInUser.UserSkills.Any(x => x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.OOA);
                            if (loggedInUser.IsOOAMenuVisible)
                            {
                                loggedInUser.OSTOOACanCreate = loggedInUser.UserSkills.Any(x => x.CanCreate && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.OOA);
                                loggedInUser.OSTOOACanSearch = loggedInUser.UserSkills.Any(x => x.CanSearch && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.OOA);
                            }
                            loggedInUser.IsSCCMenuVisible = loggedInUser.UserSkills.Any(x => x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.SCC);
                            if (loggedInUser.IsSCCMenuVisible)
                            {
                                loggedInUser.OSTSCCCanCreate = loggedInUser.UserSkills.Any(x => x.CanCreate && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.SCC);
                                loggedInUser.OSTSCCCanSearch = loggedInUser.UserSkills.Any(x => x.CanSearch && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.SCC);
                            }
                            loggedInUser.IsTRRMenuVisible = loggedInUser.UserSkills.Any(x => x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.TRR);
                            if (loggedInUser.IsTRRMenuVisible)
                            {
                                loggedInUser.OSTTRRCanCreate = loggedInUser.UserSkills.Any(x => x.CanCreate && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.TRR);
                                loggedInUser.OSTTRRCanSearch = loggedInUser.UserSkills.Any(x => x.CanSearch && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.TRR);
                            }
                            break;

                        case (long)WorkBasket.RPR:
                            loggedInUser.IsRPRMenuVisible = loggedInUser.UserSkills.Any(x => x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.RPR);
                            if (loggedInUser.IsRPRMenuVisible)
                            {
                                loggedInUser.RPRCanCreate  = loggedInUser.UserSkills.Any(x => x.CanCreate && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.RPR);
                                loggedInUser.RPRCanCSearch = loggedInUser.UserSkills.Any(x => x.CanSearch && x.DiscrepancyCategoryLkup == (long)DiscripancyCategory.RPR);
                            }
                            break;
                        }

                        //Set Manager Sub Menu Visibilities
                        if (RoleLkup == (long)Utility.RoleLkup.Manager || RoleLkup == (long)Utility.RoleLkup.Admin)
                        {
                            loggedInUser.CanMassReassign = loggedInUser.UserSkills.Any(x => x.CanReassign && x.WorkBasketLkup == WorkBasketLkup);
                            loggedInUser.CanMassUnlock   = loggedInUser.UserSkills.Any(x => x.CanUnlock && x.WorkBasketLkup == WorkBasketLkup);
                            loggedInUser.CanMassUpdate   = loggedInUser.UserSkills.Any(x => x.CanMassUpdate && x.WorkBasketLkup == WorkBasketLkup);
                            loggedInUser.CanMassUpload   = loggedInUser.UserSkills.Any(x => x.CanUpload && x.WorkBasketLkup == WorkBasketLkup);
                        }

                        if (loggedInUser.LocationLkup == (long)Location.Onshore && loggedInUser.IsRestrictedUser)
                        {
                            loggedInUser.IsRestrictedUser = true;
                        }
                        else
                        {
                            loggedInUser.IsRestrictedUser = false;
                        }

                        LastActivity = DateTime.Now;

                        Session[ConstantTexts.CurrentUserSessionKey] = loggedInUser;
                        return(RedirectToAction("Home", "Home"));
                    }
                    else
                    {
                        Session[ConstantTexts.CurrentUserSessionKey] = null;
                        UIUserLogin loggedInUser;
                        if (LoadCurrentUserSession(out loggedInUser))
                        {
                            goto ReLogin;
                        }
                        return(View(loggedInUser));
                    }
                }
                Session[ConstantTexts.CurrentUserSessionKey] = null;
                return(RedirectToAction("Login", "Login"));
            }
            catch (Exception ex)
            {
                BLCommon.LogError(0, MethodBase.GetCurrentMethod().Name, (long)ErrorModuleName.Login, (long)ExceptionTypes.Uncategorized, string.Empty, ex.ToString());
                return(RedirectToAction("Maintenance", "Error", new { Error = MethodBase.GetCurrentMethod().Name + " Action terminated and redirected to Maintenance. Error:" + ex.ToString() }));
            }
        }