protected async void UpdateForm()
 {
     if (Request["isUpdate"] == "true")
     {
         string newpass = Request["txt_newpass"];
         string oldpass = Request["txt_oldpass"];
         if (!string.IsNullOrEmpty(newpass))
         {
             if (!string.IsNullOrEmpty(oldpass))
             {
                 if (newpass == Request["txt_newpass2"])
                 {
                     store = new UserStore<User>(new ApplicationDbContext());
                     manager = new Microsoft.AspNet.Identity.UserManager<User>(store);
                     User user1 = manager.FindById(HttpContext.Current.User.Identity.GetUserId());
                     var task = await manager.ChangePasswordAsync(u.Id, oldpass, newpass);
                     if (task.Errors.ToList().Count > 0)
                     {
                         SiteLogic.AddError(task.Errors.ToList()[0]);
                     } else {
                         FormMessage.ShowSuccess(GetLocalResourceObject("err1").ToString());
                     }
                 }
                 else SiteLogic.AddError(GetLocalResourceObject("err2").ToString());
             }
             else SiteLogic.AddError(GetLocalResourceObject("err3").ToString());
         }
         else SiteLogic.AddError(GetLocalResourceObject("err4").ToString());
     }
 }
Example #2
0
        public IIdentityManagerService Create()
        {
#if USE_INT_PRIMARYKEY
            var db      = new IdentityDbContext <CustomUser, CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(connString);
            var store   = new UserStore <CustomUser, CustomRole, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(db);
            var usermgr = new UserManager <CustomUser, int>(store);
            usermgr.PasswordValidator = new PasswordValidator
            {
                RequiredLength = 3
            };

            var rolestore = new RoleStore <CustomRole, int, CustomUserRole>(db);
            var rolemgr   = new RoleManager <CustomRole, int>(rolestore);

            var svc     = new Thinktecture.IdentityManager.AspNetIdentity.AspNetIdentityManagerService <CustomUser, int, CustomRole, int>(usermgr, rolemgr);
            var dispose = new DisposableIdentityManagerService(svc, db);
            return(dispose);
#else
            var db        = new IdentityDbContext <IdentityUser>(this.connString);
            var userstore = new UserStore <IdentityUser>(db);
            var usermgr   = new Microsoft.AspNet.Identity.UserManager <IdentityUser>(userstore);
            usermgr.PasswordValidator = new Microsoft.AspNet.Identity.PasswordValidator
            {
                RequiredLength = 3
            };

            var rolestore = new RoleStore <IdentityRole>(db);
            var rolemgr   = new Microsoft.AspNet.Identity.RoleManager <IdentityRole>(rolestore);

            var svc     = new Thinktecture.IdentityManager.AspNetIdentity.AspNetIdentityManagerService <IdentityUser, string, IdentityRole, string>(usermgr, rolemgr);
            var dispose = new DisposableIdentityManagerService(svc, db);
            return(dispose);
#endif
        }
Example #3
0
        public ActionResult GetUserIDLogic()
        {
            string          UserID      = User.Identity.GetUserId();
            string          UserName    = User.Identity.GetUserName();
            ApplicationUser user        = _AccountContext.Users.Where(u => u.UserName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
            var             userManager = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(_AccountContext));

            ViewBag.UserRoles = userManager.GetRoles(user.Id);
            foreach (var role in ViewBag.UserRoles)
            {
                switch (role)
                {
                case "Admin":
                    return(RedirectToAction("AdminHomePage", new { Controller = "Admin" }));

                case "Staff":
                    return(RedirectToAction("ManageUniversities", new { Controller = "Admin" }));

                case "Applicant":
                    return(RedirectToAction("ShowUserProfile", new { UserID = UserID, Controller = "Applicant" }));

                default:
                    break;
                }
            }

            return(View());
        }
Example #4
0
        public ActionResult CreateEmployee(FormCollection form)
        {
            bool isAvailable = true;

            ViewBag.error = "";
            var    UserManager = new Microsoft.AspNet.Identity.UserManager <AspNetUser>(new UserStore <AspNetUser>(context));
            string UserName    = form["txtEmail"];
            string email       = form["txtEmail"];
            string pwd         = "Caretta.97";

            List <AspNetUser> uList = db.Users.ToList();

            foreach (var item in uList)
            {
                if (item.Email == email)
                {
                    ViewBag.error = "The employee you want to add is already registered.";
                    isAvailable   = false;
                }
            }
            if (isAvailable)
            {
                var user = new AspNetUser();
                user.UserName   = UserName;
                user.Email      = email;
                user.pwdChanged = false;
                var newUser = UserManager.Create(user, pwd);
                UserManager.AddToRole(user.Id, "personel");
                ViewBag.error = "The employee you want to add has been successfully registered.";
            }

            return(View());
        }
        public ActionResult DifferentPage(string UserName)
        {
            string          Role       = null;
            string          Page       = null;
            string          controller = null;
            ApplicationUser user       = _context.Users.Where(u => u.UserName.Equals(UserName,
                                                                                     StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
            var um = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>
                         (new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(_context));

            foreach (string rm in um.GetRoles(user.Id))
            {
                Role = rm;
            }

            if (Role == "Applicant")
            {
                Page       = "searchUserProfile";
                controller = "Profiles";
            }
            if (Role == "Admin" || Role == "Staff")
            {
                Page       = "AdminAndStaff";
                controller = "Admin";
            }
            return(RedirectToAction(Page, controller));
        }
Example #6
0
        public async Task <ClaimsIdentity> GenerateUserIdentityAsync(Microsoft.AspNet.Identity.UserManager <WfpUser, string> manager)
        {
            // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
            var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);

            // Add custom user claims here
            try
            {
                using (WfpictContext ctx = new WfpictContext())
                {
                    var userId = userIdentity.GetUserId();
                    var user   = ctx.Users.Include(x => x.Roles).FirstOrDefault(x => x.Id == userId);
                    if (user != null)
                    {
                        foreach (var role in user.Roles)
                        {
                            var roleClaims = ctx.RoleClaims.Include("Claim").Where(x => x.RoleId == role.RoleId);
                            foreach (var roleClaim in roleClaims)
                            {
                                userIdentity.AddClaim(new Claim(ClaimTypes.UserData, roleClaim.Claim.ClaimValue));
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                // ignored
            }
            return(userIdentity);
        }
Example #7
0
        public ActionResult ManageUserRoles(string UserName, string RoleName)
        {
            ApplicationUser user     = _context.Users.Where(u => u.UserName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
            var             um       = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(_context));
            var             idResult = um.AddToRole(user.Id, RoleName);
            // Prepopulate roles for the view dropdown
            var roleList = _context.Roles.OrderBy(r => r.Name).ToList().Select(rr => new SelectListItem
            {
                Value = rr.Name.ToString(),
                Text  = rr.Name
            }).ToList();

            ViewBag.Roles = roleList;

            // Prepopulate users for the view dropdown
            var userList = _context.Users.OrderBy(u => u.UserName).ToList().Select(uu => new SelectListItem
            {
                Value = uu.UserName.ToString(),
                Text  = uu.UserName
            }).ToList();

            ViewBag.Users = userList;

            return(View("ManageUserRoles"));
        }
Example #8
0
        protected override void Seed(MPSContext context)
        {
            var roleManager = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(new ApplicationDbContext()));
            var userManager = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new UserStore <ApplicationUser>(new ApplicationDbContext()));

            //uzytkownicy o roli Admin
            roleManager.Create(new IdentityRole("Admin"));
            var u1 = new ApplicationUser
            {
                Email    = "*****@*****.**",
                UserName = "******"
            };
            string passwor = "Biblioteka1@";

            userManager.Create(u1, passwor);
            userManager.AddToRole(u1.Id, "Admin");

            var uu1 = new UserNew
            {
                UserName = "******",
                Id       = u1.Id
            };

            context.User.Add(uu1);
            context.SaveChanges();

            /*   var P = new Person
             * {
             *     Name = "",
             *     Surname = ""
             *
             * };*/
            // context.Person.Add(P);
            //   context.SaveChanges();
        }
        public async Task <ActionResult> Register(RegisterViewModel model)
        {
            if (ModelState.IsValid)
            {
                var user = new ApplicationUser {
                    UserName = model.Email, Email = model.Email
                };
                var result = await UserManager.CreateAsync(user, model.Password);

                var um = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>
                             (new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(_context));
                um.AddToRole(user.Id, "Applicant");
                if (result.Succeeded)
                {
                    await SignInManager.SignInAsync(user, isPersistent : false, rememberBrowser : false);

                    // For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
                    // Send an email with this link
                    // string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
                    // var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
                    // await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");



                    return(RedirectToAction("AddProfile", "NAAAdmin"));
                }
                AddErrors(result);
            }

            // If we got this far, something failed, redisplay form
            return(View(model));
        }
        public async Task TestMethod0()
        {
            IdentityTableContext<IdentityUser> context = new IdentityTableContext<IdentityUser>(
                 new CloudStorageAccount(new StorageCredentials("c1azuretests", File.ReadAllText("C:\\dev\\storagekey.txt")), true));


            var store = new UserStore<IdentityUser>(context);
            var mgr = new Microsoft.AspNet.Identity.UserManager<IdentityUser>(store);

            var obj = await mgr.FindAsync(new UserLoginInfo("google", "notfound"));

            Assert.IsNull(obj);

            var username="******"+Guid.NewGuid().ToString().Substring(0,5);
            var user = new IdentityUser(username);
            var result = await mgr.CreateAsync(user);

            Trace.WriteLine(string.Join(", ", result.Errors));
            Assert.AreEqual(0, result.Errors.Count());


            var userFromDb = await mgr.FindByIdAsync(user.Id);
           Assert.IsNotNull(userFromDb); 

            


        }
Example #11
0
        private void createRolesandUsers(string username, string userType)
        {
            ApplicationDbContext context = new ApplicationDbContext();

            var roleManager = new Microsoft.AspNet.Identity.RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
            var UserManager = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new UserStore <ApplicationUser>(context));


            if (!roleManager.RoleExists("Employee") && userType == "1")
            {
                // first we create Admin rool
                var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
                role.Name = "Employee";
                roleManager.Create(role);
            }
            if (!roleManager.RoleExists("Customer") && userType == "2")
            {
                // first we create Admin rool
                var role = new Microsoft.AspNet.Identity.EntityFramework.IdentityRole();
                role.Name = "Customer";
                roleManager.Create(role);
            }
            string s;

            if (userType == "1")
            {
                s = "Employee";
            }
            else
            {
                s = "Customer";
            }
            var result1 = UserManager.AddToRole(username, s);
        }
Example #12
0
        public async Task <ClaimsIdentity> GenerateUserIdentityAsync(Microsoft.AspNet.Identity.UserManager <MarketplaceUser> manager)
        {
            // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
            var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);

            // Add custom user claims here
            return(userIdentity);
        }
Example #13
0
        public async Task <ClaimsIdentity> GenerateUserIdentityAsync(Microsoft.AspNet.Identity.UserManager <ApplicationUser> manager)
        {
            // Observe que o authenticationType deve corresponder àquele definido em CookieAuthenticationOptions.AuthenticationType
            var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);

            // Adicionar declarações de usuário personalizado aqui
            return(userIdentity);
        }
Example #14
0
        //from webapi for OWin
        public async Task <ClaimsIdentity> GenerateUserIdentityAsync(Microsoft.AspNet.Identity.UserManager <AspNetIdentityUser, string> manager, string authenticationType)
        {
            // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
            var userIdentity = await manager.CreateIdentityAsync(this, authenticationType);

            // Add custom user claims here
            return(userIdentity);
        }
        public async Task <ActionResult> Login(LoginViewModel model, string returnUrl)
        {
            ApplicationUser user =
                _context.Users.Where(u => u.UserName.Equals(model.Email, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
            var um = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(_context));

            ViewBag.RolesForThisUser = um.GetRoles(user.Id);
            string uid = user.Id;


            if (!ModelState.IsValid)
            {
                return(View(model));
            }

            // This doesn't count login failures towards account lockout
            // To enable password failures to trigger account lockout, change to shouldLockout: true
            var result = await SignInManager.PasswordSignInAsync(model.Email, model.Password, model.RememberMe, shouldLockout : false);

            switch (result)
            {
            case SignInStatus.Success:
                ViewBag.userId = uid;
                if (um.GetRoles(user.Id) == null)
                {
                    return(RedirectToAction("ApplicantHome", new { Controller = "Home" }));
                }
                else
                {
                    if (um.GetRoles(user.Id).Contains("Admin"))
                    {
                        return(RedirectToAction("AdminHome", new { Controller = "Home" }));
                    }
                    else if (um.GetRoles(user.Id).Contains("Staff"))
                    {
                        return(RedirectToAction("StaffHome", new { Controller = "Home" }));
                    }
                    else
                    {
                        return(RedirectToAction("ApplicantHome", new { Controller = "Home" }));
                    }
                }


            case SignInStatus.LockedOut:
                return(View("Lockout"));

            case SignInStatus.RequiresVerification:
                return(RedirectToAction("SendCode", new { ReturnUrl = returnUrl, RememberMe = model.RememberMe }));

            case SignInStatus.Failure:
            default:
                ModelState.AddModelError("", "Invalid login attempt.");
                return(View(model));
            }
        }
Example #16
0
        protected override void Seed(ThingWall.Data.DataContext context)
        {
            //PROTIP: tutaj mo¿na wype³niæ bazê danych wstêpnymi danymi
            //UWAGA: trzeba sprawdzaæ, czy dany rekord ju¿ istnieje, Seed uruchamiany jest po ka¿dej migracji

            var examples = new List <ExampleItem>()
            {
                new ExampleItem()
                {
                    Name = "Test 1"
                },
                new ExampleItem()
                {
                    Name = "Test 2"
                },
                new ExampleItem()
                {
                    Name = "Test 3"
                }
            };

            //PROTIP: mechanizm u¿ytkowników dostarza ASP.NET Identity
            //klasa UserManager pozwala trochê ³atwiej ich ogarn¹æ
            var userManager = new Microsoft.AspNet.Identity.UserManager <User>(new UserStore <User>(context));

            var testUser = userManager.FindByEmail("*****@*****.**");

            if (testUser == null)
            {
                var hasher = new PasswordHasher();

                testUser = new User()
                {
                    UserName       = "******",
                    Email          = "*****@*****.**",
                    EmailConfirmed = true,
                    PasswordHash   = hasher.HashPassword("test"),
                    Nick           = "NowyNick"
                };

                userManager.Create(testUser);
            }

            foreach (var example in examples)
            {
                if (!context.ExampleItems.Any(i => i.Name == example.Name))
                {
                    //PROTIP: ustawianie klucza obcego wystarczy do "zrobienia" relacji
                    example.OwnerId = testUser.Id;
                    context.ExampleItems.Add(example);
                }
            }

            //PROTIP: SaveChanges poza pêtl¹ wrzuca wszystkie zmiany w kolejce jednym zapytaniem
            context.SaveChanges();
        }
        public MyUser getMyUser()
        {
            this.ApplicationDbContext = new ApplicationDbContext();
            this.UserManager          = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new UserStore <ApplicationUser>(this.ApplicationDbContext));
            ApplicationUser user = System.Web.HttpContext.Current.GetOwinContext().GetUserManager <ApplicationUserManager>().FindById(System.Web.HttpContext.Current.User.Identity.GetUserId());

            return(new MyUser {
                UserName = user.UserName, Address = user.Address, FullName = user.FullName, Email = user.Email
            });
        }
        public AspNetIdentityUserService(Microsoft.AspNet.Identity.UserManager <TUser> userManager, Func <string> parseSubject = null)
        {
            if (userManager == null)
            {
                throw new ArgumentNullException("userManager");
            }

            _userManager        = userManager;
            EnableSecurityStamp = true;
        }
Example #19
0
        public AccountController()
        {
            var userStore = new UserStore <ApplicationUser>(new Identity.IdentityDbContext());

            userManager = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(userStore);

            var roleStore = new RoleStore <ApplicationRole>(new Identity.IdentityDbContext());

            roleManager = new Microsoft.AspNet.Identity.RoleManager <ApplicationRole>(roleStore);
        }
        public void AddUserRole(string id, string role)
        {
            UserStore<ApplicationUser> userStore = new UserStore<ApplicationUser>(db);
            Microsoft.AspNet.Identity.UserManager<ApplicationUser> userManager = new Microsoft.AspNet.Identity.UserManager<ApplicationUser>(userStore);

            userManager.AddToRole(id, role);

            db.SaveChanges();
            //return userManager;
        }
 public ActionResult GetRolesforUser(string UserName)
 {
     if (!string.IsNullOrWhiteSpace(UserName))
     {
         var user = _context.Users.FirstOrDefault(u => u.UserName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase));
         var um   = new Microsoft.AspNet.Identity.UserManager <IdentityUser>(new Microsoft.AspNet.Identity.EntityFramework.UserStore <IdentityUser>(_context));
         ViewBag.RolesForThisUser = um.GetRoles(user.Id);
     }
     return(View("GetRolesforUserConfirmed"));
 }         // GET: Admin
Example #22
0
        public async Task <ClaimsIdentity> GenerateUserIdentityAsync(Microsoft.AspNet.Identity.UserManager <eCommerceUser> manager)
        {
            // Note the authenticationType must match the one defined in CookieAuthenticationOptions.AuthenticationType
            var userIdentity = await manager.CreateIdentityAsync(this, DefaultAuthenticationTypes.ApplicationCookie);

            // Add custom user claims here
            userIdentity.AddClaim(new Claim("Email", Email));
            userIdentity.AddClaim(new Claim("Picture", this.Picture != null ? this.Picture.URL : string.Empty));

            return(userIdentity);
        }
        public static IUserManager Create()
        {
            var db = new IdentityDbContext<IdentityUser>("DefaultConnection");
            var store = new UserStore<IdentityUser>(db);
            var mgr = new Microsoft.AspNet.Identity.UserManager<IdentityUser>(store);
            return new Thinktecture.IdentityManager.AspNetIdentity.UserManager<IdentityUser>(mgr, db);

            //var db = new CustomDbContext("CustomAspId");
            //var store = new CustomUserStore(db);
            //var mgr = new CustomUserManager(store);
            //return new Thinktecture.IdentityManager.AspNetIdentity.UserManager<CustomUser, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(mgr, db);
        }
Example #24
0
        public ActionResult AssignRole(FormCollection form)
        {
            string username = form["txtUserName"];
            string rolname  = form["RoleName"];

            AspNetUser user = context.Users.Where(u => u.UserName.Equals(username, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();

            var userManager = new Microsoft.AspNet.Identity.UserManager <AspNetUser>(new UserStore <AspNetUser>(context));

            userManager.AddToRole(user.Id, rolname);
            return(View("Index"));
        }
        //[Authorize(Roles = "Admin")]
        public ActionResult ManageUserRoles(string UserName, string RoleName)
        {
            ApplicationUser user     = _DBcontext.Users.Where(u => u.UserName.Equals(UserName, StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
            var             um       = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(_DBcontext));
            var             idResult = um.AddToRole(user.Id, RoleName);

            //populate roles for the view dropdown
            ViewBag.Roles = _abcLib.PopulateRoleListItem();

            //populate users for the view dropdown
            ViewBag.Users = _abcLib.PopulateUserListItem();
            return(View("ManageUserRoles"));
        }
        public static IUserManager Create()
        {
            var db    = new IdentityDbContext <IdentityUser>("DefaultConnection");
            var store = new UserStore <IdentityUser>(db);
            var mgr   = new Microsoft.AspNet.Identity.UserManager <IdentityUser>(store);

            return(new Thinktecture.IdentityManager.AspNetIdentity.UserManager <IdentityUser>(mgr, db));

            //var db = new CustomDbContext("CustomAspId");
            //var store = new CustomUserStore(db);
            //var mgr = new CustomUserManager(store);
            //return new Thinktecture.IdentityManager.AspNetIdentity.UserManager<CustomUser, int, CustomUserLogin, CustomUserRole, CustomUserClaim>(mgr, db);
        }
Example #27
0
        public void CreateAdmin()
        {
            var userManger = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
            var user       = new ApplicationUser();

            user.Email    = "*****@*****.**";
            user.UserName = "******";
            var isUserExist = userManger.Create(user, "123456");

            if (isUserExist.Succeeded)
            {
                userManger.AddToRole(user.Id, "Admin");
            }
        }
        public ActionResult ManageUserRoles(UserViewModel model)
        {
            var user = _context.Users.FirstOrDefault(u => u.UserName.Equals(model.UserName, StringComparison.CurrentCultureIgnoreCase));
            var um   = new Microsoft.AspNet.Identity.UserManager <IdentityUser>(new Microsoft.AspNet.Identity.EntityFramework.UserStore <IdentityUser>(_context));

            um.RemoveFromRole(user.Id, Helpers.Constants.Roles.Applicant);
            um.RemoveFromRole(user.Id, Helpers.Constants.Roles.Admin);
            um.RemoveFromRole(user.Id, Helpers.Constants.Roles.Staff);
            var idResult = um.AddToRole(user.Id, model.RoleName);

            model = GetUserViewModel(model.UserName);

            return(View("ManageUserRoles", model));
        }
Example #29
0
        public bool AddRole(string role)
        {
            var userManager = new Microsoft.AspNet.Identity.UserManager <MyUser, int>(new MyUserStore(new ApplicationDbContext()));

            try
            {
                userManager.AddToRole(this.Id, role);
                return(true);
            }
            catch
            {
                return(false);
            }
        }
Example #30
0
        public List <string> GetUserRoles(string username)
        {
            var           roleManager     = new RoleManager <IdentityRole>(new RoleStore <IdentityRole>(context));
            var           UserManager     = new Microsoft.AspNet.Identity.UserManager <User>(new UserStore <User>(context));
            List <string> ListOfRoleNames = new List <string>();
            var           ListOfRoleIds   = UserManager.FindById(username).Roles.Select(x => x.RoleId).ToList();

            foreach (string id in ListOfRoleIds)
            {
                string rolename = roleManager.FindById(id).Name;
                ListOfRoleNames.Add(rolename);
            }

            return(ListOfRoleNames);
        }
        protected override string CreateUniqueUserName(Microsoft.AspNet.Identity.UserManager <ApplicationUser> userManager, Microsoft.AspNet.Identity.Owin.ExternalLoginInfo externalLoginInfo)
        {
            Assert.ArgumentNotNull((object)userManager, nameof(userManager));
            Assert.ArgumentNotNull((object)externalLoginInfo, nameof(externalLoginInfo));
            IdentityProvider identityProvider = this.FederatedAuthenticationConfiguration.GetIdentityProvider(externalLoginInfo.ExternalIdentity);

            if (identityProvider == null)
            {
                throw new InvalidOperationException("Unable to retrieve identity provider for given identity");
            }
            string domain = identityProvider.Domain;
            string email  = externalLoginInfo.DefaultUserName;

            // return email and domain
            return($"{domain}\\\\\\\\{email}");
        }
 public ActionResult GetRolesforUser(string UserName)
 {
     if (!string.IsNullOrWhiteSpace(UserName))
     {
         ApplicationUser user = _context.Users.Where(u => u.UserName.Equals(UserName,
                                                                            StringComparison.CurrentCultureIgnoreCase)).FirstOrDefault();
         var um = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>
                      (new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(_context));
         if (um.GetRoles(user.Id) != null)
         {
             ViewBag.RolesForThisUser = um.GetRoles(user.Id);
         }
         ViewBag.ThisUser = user.UserName;
     }
     return(View("CheakRole"));
 }
        /// <summary>
        /// Step 1 : user creation
        /// </summary>
        /// <param name="model">Registration details</param>
        /// <returns></returns>
        public int RegisterUser(ParticipantRegistration model)
        {
            string createdBy     = string.Empty;
            int    userDetailsID = 0;

            #region Create useer
            using (OCASIAMeetingUOW db = new OCASIAMeetingUOW())
            {
                var res = db.Repository <ApplicationUser>().GetAll().Where(f => f.Email == model.Email).FirstOrDefault();
                if (res == null)
                {
                    var user = new ApplicationUser()
                    {
                        UserName         = model.Email,
                        Email            = model.Email,
                        RoleCustomID     = 3,
                        IsActive         = true,
                        IspasswordActive = true
                    };
                    var userManager = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(new Microsoft.AspNet.Identity.EntityFramework.UserStore <ApplicationUser>(new OCASIAMeetingContext()));
                    var ures        = userManager.Create(user, model.Password);
                    if (ures.Succeeded)
                    {
                        // userManager.AddClaim(user.Id, new System.Security.Claims.Claim("FullName", model.Email));
                        Passwordhash mdl = new Passwordhash()
                        {
                            UserId   = user.Id,
                            Password = model.Password
                        };
                        db.Repository <Passwordhash>().Add(mdl);
                        db.SaveChanges();
                        createdBy = mdl.UserId;
                    }
                }
                else
                {
                    return(-1);
                }
            }
            #endregion
            if (string.IsNullOrEmpty(createdBy))
            {
                return(userDetailsID);
            }
            userDetailsID = CreateUserDetails(model, createdBy);
            return(userDetailsID);
        }
        public async Task <ActionResult> EditProfile(ApplicationUser _user)
        {
            ////get current user and update
            //var userCurnt = await UserManager.FindByIdAsync(User.Identity.GetUserId());
            //userCurnt.Image = _user.Image;
            //userCurnt.UserName = _user.UserName;
            //userCurnt.Email = _user.Email;

            //var updateResult = await UserManager.UpdateAsync(user);
            //if (updateResult.Succeeded)
            //{
            //    //do something and return
            //    return RedirectToAction("showprofile");
            //}
            ////failed - do something else and return
            //return View();


            if (!ModelState.IsValid)
            {
                return(View(_user));
            }

            var userStore = new UserStore <ApplicationUser>(new
                                                            ApplicationDbContext());
            var appManager = new Microsoft.AspNet.Identity.UserManager <ApplicationUser>(userStore);

            var currentUser = appManager.FindByEmail(_user.Email);

            // here you can assign the updated values
            currentUser.Image    = _user?.Image;
            currentUser.Email    = _user?.Email;
            currentUser.UserName = _user?.UserName;

            // and rest fields are goes here
            await appManager.UpdateAsync(currentUser);

            var ctx = userStore.Context;

            ctx.SaveChanges();

            // now you can redirect to some other method or-else you can return
            // to this view itself by returning the data

            return(RedirectToAction("showProfile"));
        }
    private void UpdateFormNew()
    {
        if (!string.IsNullOrEmpty(Request["isUpdate"]) && Request["isUpdate"] == "true")
        {
            store = new UserStore<User>(new ApplicationDbContext());
            manager = new Microsoft.AspNet.Identity.UserManager<User>(store);

            User user = manager.FindById(HttpContext.Current.User.Identity.GetUserId());
            TryUpdateModel(user, new FormValueProvider(ModelBindingExecutionContext));

            if (ModelState.IsValid)
            {
                var result = Task.Run(() => manager.UpdateAsync(user)).Result;
                store.Context.SaveChanges();
                UL.SetLoggedUser(user);
                FormMessage.ShowSuccess(GetLocalResourceObject("Success").ToString());
            }
            else
            {
                u.Email = u.UserName;
            }
        }
    }
        public void RemoveUserRole(string id, string role)
        {
            UserStore<ApplicationUser> userStore = new UserStore<ApplicationUser>(db);
            Microsoft.AspNet.Identity.UserManager<ApplicationUser> userManager = new Microsoft.AspNet.Identity.UserManager<ApplicationUser>(userStore);
            //var oldRole = System.Web.Security.Roles.GetRolesForUser().Single();
            //var account = new AccountController();
            //var oldRole = account.UserManager.GetRoles(id);

            userManager.RemoveFromRole(id, role);
            db.SaveChanges();
            //return userManager;
        }