internal bool RemoveUser(string username)
 {
     Models.ApplicationDbContext context = new Models.ApplicationDbContext();
     var userMgr = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
     userMgr.Delete(userMgr.FindByName(username));
     return true;
 }
Пример #2
0
 public void Delete(ApplicationUser user)
 {
     var userStore = new UserStore<ApplicationUser>(this.Context);
     var userManager = new UserManager<ApplicationUser>(userStore);
     userManager.Delete(user);
     var context = userStore.Context;
     context.SaveChanges();
 }
Пример #3
0
        public static bool DeleteUser(string userName)
        {
            var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(userContext));
            var userASP     = userManager.FindByEmail(userName);

            if (userASP == null)
            {
                return(false);
            }
            var response = userManager.Delete(userASP);

            return(response.Succeeded);
        }
        public HttpResponseMessage Delete(string user)
        {
            var manager = new UserManager <IdentityUser>(credentials);
            var u       = manager.FindByName(user);
            var result  = manager.Delete(u);

            if (result.Succeeded)
            {
                return(Request.CreateResponse(HttpStatusCode.OK));
            }

            return(Request.CreateResponse(HttpStatusCode.BadRequest));
        }
Пример #5
0
        public IHttpActionResult Delete()
        {
            int uid = Auth.CheckToken(Request.Headers);

            if (uid == 0)
            {
                return(StatusCode(HttpStatusCode.Forbidden));
            }

            bool ret = UserManager.Delete(uid);

            return(Ok(ret));
        }
Пример #6
0
        public IHttpActionResult Delete(string id)
        {
            ApplicationUser applicationUser = userManager.Users.FirstOrDefault(s => s.Id == id);

            if (applicationUser == null)
            {
                return(NotFound());
            }

            userManager.Delete(applicationUser);

            return(Ok(applicationUser));
        }
Пример #7
0
        public IHttpActionResult DeleteUser(string id)
        {
            ApplicationUser user = UserManager.Users.FirstOrDefault(x => x.Id == id);

            if (user == null)
            {
                return(NotFound());
            }

            UserManager.Delete(user);

            return(Ok(user));
        }
Пример #8
0
        private static void DeleteUser(UserManager userManager)
        {
            int id;

            Console.Write("Id : ");
            id = Convert.ToInt32(Console.ReadLine());

            User userToDelete = new User {
                UserId = id
            };

            userManager.Delete(userToDelete);
        }
Пример #9
0
 /* Note that there are zero references to DeleteIdentityUser(). This is purposeful. The original idea
  * was to delete an Identity entry when the corresponding User entry was deleted from our database.
  * Instead though, we will simply set the IsActive property for a User in our database to false (and
  * not actually delete them) so there is no need to delete the corresponding Identity entry.
  */
 /// <summary>
 /// Delete a user from the Identity system
 /// </summary>
 /// <param name="userEmail"></param>
 public static void DeleteIdentityUser(string userEmail)
 {
     using (var db = new ApplicationDbContext())
     {
         var userManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(db));
         var user        = userManager.FindByName(userEmail); // note that the user name is their email address
         if (user != null)
         {
             userManager.Delete(user);
         }
         db.SaveChanges();
     }
 }
Пример #10
0
        private static void UserAddedAndDeleted(UserManager userManager)
        {
            var result = userManager.Add(new User {
                FirstName = "Elif", LastName = "Bakıcı", Email = "*****@*****.**", Password = "******"
            });

            Console.WriteLine(result.Message);
            var result2 = userManager.Delete(new User {
                Id = 3
            });

            Console.WriteLine(result2.Message);
        }
Пример #11
0
        public static object OrgSignUp(OrgVm data, string password)
        {
            ApplicationUser user = null;

            try
            {
                user = new ApplicationUser()
                {
                    UserName = data.UserName, Email = data.UserName
                };
                UserMgr.PasswordValidator = new PasswordValidator()
                {
                    RequireUppercase = false
                };

                var ir = UserMgr.Create(user, password);
                if (!ir.Succeeded)
                {
                    return(IdentityErrors(ir.Errors));
                }

                var mr = OrgMgr.SignUp(ref data, password, Utils.UploadFolder);
                if (mr.Status == ResponseStatus.Success)
                {
                    return(Utils.ServiceResponse(PageCode, mr));
                }

                UserMgr.Delete(user);
                return(Utils.ServiceResponse(PageCode, mr));
            }
            catch (Exception ex)
            {
                if (user != null)
                {
                    UserMgr.Delete(user);
                }
                return(Utils.ServiceResponse(new ModelResponse(ex)));
            }
        }
Пример #12
0
        private static void UserDelete(UserManager userManager)
        {
            Console.WriteLine("---------- Kullanıcı Kaydı Silme Ekranı ----------");
            Console.WriteLine("Kullanıcı Id:");
            int  id         = Convert.ToInt32(Console.ReadLine());
            User deleteUser = new User {
                UserId = id
            };

            var result = userManager.Delete(deleteUser);

            SuccessUser(userManager, result);
        }
Пример #13
0
 public void DeleteUser(string userId, string roleName)
 {
     using (var db = new ErasmusDbContext())
     {
         var store   = new UserStore <ErasmusUser>(db);
         var manager = new UserManager <ErasmusUser>(store);
         var user    = manager.FindById(userId);
         if (user != null && manager.IsInRole(userId, roleName))
         {
             manager.Delete(user);
         }
     }
 }
Пример #14
0
        public void WhenAUserIsDeletedTheDatabaseIsUpdated()
        {
            var userManager = new UserManager();

            using (var db = new PasswordManagerContext())
            {
                var numberOfUsersBefore = db.Users.Count();
                userManager.Delete(_testUser.Id);
                var numberOfUsersAfter = db.Users.Count();

                Assert.AreEqual(numberOfUsersBefore - 1, numberOfUsersAfter);
            }
        }
Пример #15
0
        public void TestDeleteUser()
        {
            UserManager manager = new UserManager();

            manager.Seed();

            manager.Delete(1);
            var allUsers    = manager.GetAll();
            var deletedUser = manager.GetByEmailAndPassword(email: "Email1", password: "******");

            Assert.AreEqual(1, allUsers.Count);
            Assert.IsNull(deletedUser);
        }
Пример #16
0
        public ActionResult SaveData(UserChangeViewModel users)
        {
            if (users.updated != null)
            {
                foreach (var item in users.updated)
                {
                    var user = UserManager.FindById(item.Id);
                    user.UserName    = item.UserName;
                    user.Email       = item.Email;
                    user.FullName    = item.FullName;
                    user.CompanyCode = item.CompanyCode;
                    user.CompanyName = item.CompanyName;
                    user.AccountType = item.AccountType;
                    user.PhoneNumber = item.PhoneNumber;
                    user.EnabledChat = item.EnabledChat;
                    user.Gender      = item.Gender;
                    var result = UserManager.Update(user);
                }
            }
            if (users.deleted != null)
            {
                foreach (var item in users.deleted)
                {
                    var user = new ApplicationUser {
                        UserName = item.UserName, Email = item.Email, FullName = item.FullName, CompanyCode = item.CompanyCode, CompanyName = item.CompanyName
                    };
                    var result = UserManager.Delete(user);
                }
            }
            if (users.inserted != null)
            {
                foreach (var item in users.inserted)
                {
                    var user = new ApplicationUser
                    {
                        UserName    = item.UserName,
                        Email       = item.Email,
                        FullName    = item.FullName,
                        Gender      = item.Gender,
                        CompanyCode = item.CompanyCode,
                        CompanyName = item.CompanyName,
                        PhoneNumber = item.PhoneNumber,
                        AccountType = item.AccountType
                    };
                    var result = UserManager.Create(user, "123456");
                }
            }


            return(Json(new { success = true }, JsonRequestBehavior.AllowGet));
        }
Пример #17
0
        public ActionResult DeleteConfirmed()
        {
            ApplicationUser user = UserManager.FindByEmail(User.Identity.Name);

            if (user != null)
            {
                IdentityResult result = UserManager.Delete(user);
                if (result.Succeeded)
                {
                    return(RedirectToAction("Logout", "Account"));
                }
            }
            return(RedirectToAction("Index", "Home"));
        }
Пример #18
0
      public ActionResult DeleteConfirmed(string id)
      {
          if (id != null)
          {
              Patients patients = db.Patients.FirstOrDefault(x => x.UserId == id);
              var      user     = userManager.FindById(id);
              userManager.Delete(user);
              db.Patients.Remove(patients);
              db.SaveChanges();
              TempData["successPatientDelete"] = "*Hasta kaydı başarıyla silinmiştir.";
          }

          return(RedirectToAction("Index"));
      }
Пример #19
0
        public ActionResult Delete()
        {
            // Alle Alumni löschen
            foreach (var alumni in Db.Alumnae.ToList())
            {
                var user = UserManager.FindById(alumni.UserId);
                UserManager.Delete(user);

                Db.Alumnae.Remove(alumni);
            }
            Db.SaveChanges();

            return(RedirectToAction("Index"));
        }
Пример #20
0
        public bool DeleteUser(string id)
        {
            var user   = UserManager.FindById(id);
            var result = UserManager.Delete(user);

            if (!result.Succeeded)
            {
                foreach (string str in result.Errors)
                {
                    ErrorMessage += str;
                }
            }
            return(result.Succeeded);
        }
Пример #21
0
        private void DeleteUser(ExtendedUserCustom extUser)
        {
            var user = UserManager.FindByEmail(extUser.Email);

            //not found?
            if (user == null)
            {
                throw new Exception("User not found.");
            }

            UserManager.RemoveFromRoles(user.Id, UserManager.GetRoles(user.Id).ToArray());
            UserManager.Update(user);
            UserManager.Delete(user);
        }
Пример #22
0
        public ActionResult Delete(string id, FormCollection collection)
        {
            try
            {
                var user   = UserManager.FindById(id);
                var result = UserManager.Delete(user);

                return(RedirectToAction("Index"));
            }
            catch
            {
                return(View());
            }
        }
        public ActionResult Delete(string id)
        {
            var user   = userManager.FindById(id);
            var result = userManager.Delete(user);

            if (result.Succeeded)
            {
                return(RedirectToAction("Index"));
            }
            else
            {
                return(View("Eror", new string[] { "hata olutu" }));
            }
        }
Пример #24
0
        public ActionResult Delete(long id)
        {
            try
            {
                UserManager.Delete(id);
                TempData["message"] = "Het account is verwijderd.";
            }
            catch (Exception e)
            {
                TempData["error"] = e.Message;
            }

            return(RedirectToAction("index", "Account", new { name = "" }));
        }
Пример #25
0
        public ActionResult DeleteConfirmed(string id)
        {
            User user = UserManager.FindById(id);

            if (user != null)
            {
                IdentityResult result = UserManager.Delete(user);
                if (result.Succeeded)
                {
                    return(RedirectToAction("Index", "Admin"));
                }
            }
            return(View("Error"));
        }
Пример #26
0
        public ActionResult Delete(string id)
        {
            ApplicationUser user = UserManager.FindById(id);

            if (user != null)
            {
                IdentityResult result = UserManager.Delete(user);
                if (result.Succeeded)
                {
                    return(RedirectToAction(nameof(Index), "Admin"));
                }
            }
            return(RedirectToAction(nameof(Index), "Admin"));
        }
Пример #27
0
        public IdentityResult SalonRegister(SalonAccountModel model)
        {
            IdentityResult result = null;

            try
            {
                var userStore = new UserStore <ApplicationUser>(new ApplicationDbContext());
                var manager   = new UserManager <ApplicationUser>(userStore);
                var user      = new ApplicationUser()
                {
                    UserName    = model.UserName,
                    Email       = model.Email,
                    PhoneNumber = model.PhoneNumber,
                };
                manager.PasswordValidator = new PasswordValidator()
                {
                    RequiredLength = 3
                };
                result = manager.Create(user, model.Password);
                if (result.Succeeded)
                {
                    var createRoleResult = manager.AddToRole(user.Id, RoleConstant.SALON);
                    if (createRoleResult.Succeeded)
                    {
                        var newSalon = new SalonViewModel
                        {
                            SalonName     = model.SalonName,
                            Address       = model.Address,
                            AccountId     = user.Id,
                            IsForMen      = model.IsForMen,
                            IsForWomen    = model.IsForWomen,
                            Phone         = model.PhoneNumber,
                            Email         = model.Email,
                            RatingAvarage = 0
                        };
                        _salonService.RegisterSalonAccount(newSalon);
                    }
                    else
                    {
                        manager.Delete(user);
                    }
                }
            }
            catch (Exception ex)
            {
                Elmah.ErrorSignal.FromCurrentContext().Raise(ex);
                return(new IdentityResult("Cannot create salon account"));
            }
            return(result);
        }
Пример #28
0
        public void TestDeleteuser()
        {
            UserManager manager = new UserManager();

            manager.Seed();

            manager.Delete(1);

            var allUsers    = manager.GetAll();
            var deletedUser = manager.Get(1);

            Assert.AreEqual(1, allUsers.Count);
            Assert.IsNull(deletedUser);
        }
Пример #29
0
        public async ValueTask <IActionResult> Delete(int id)
        {
            var model = new ApplicationUser {
                Id = id
            };

            (bool succeeded, string error) = await _acc.Delete(model);

            if (succeeded)
            {
                return(NoContent());
            }
            return(NotFound(new { Message = error }));
        }
Пример #30
0
        public ActionResult DeleteConfirmed(int id)
        {
            Technologist technologist = db.Technologist.Find(id);

            db.People.Remove(technologist);
            db.SaveChanges();

            var UserManager = new UserManager <ApplicationUser>(new UserStore <ApplicationUser>(ddb));
            var user        = UserManager.FindByEmail(technologist.ContactEmail);

            UserManager.Delete(user);

            return(RedirectToAction("Index"));
        }
Пример #31
0
        private void DeleteUser(ExpandedUserDTO paramExpandedUserDTO)
        {
            ApplicationUser user = UserManager.FindByName(paramExpandedUserDTO.UserName);

            // If we could not find the user, throw an exception
            if (user == null)
            {
                throw new Exception("Could not find the User");
            }

            UserManager.RemoveFromRoles(user.Id, UserManager.GetRoles(user.Id).ToArray());
            UserManager.Update(user);
            UserManager.Delete(user);
        }
Пример #32
0
        private void btnDelete_Click(object sender, EventArgs e)
        {
            if (Program.DeleteConfirm("Do you want delete this user?"))
            {
                UserManager.Delete(curUser); // Veritabanından kullanıcıyı sil

                MessageBox.Show("User successfully deleted!", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);

                refreshUsers();       // Combobox'ı güncelle

                changeVisible(false); // formu gizle
                cbxUsers.Text = "";   // Combobox'taki ismi sil
            }
        }
        public JsonResult TenantDelete(string TenantID)
        {

            var BID = db.Tenant.Where(c => c.ID == TenantID).FirstOrDefault().Apartment.Buildings.ID;
            var AID = db.Tenant.Where(c => c.ID == TenantID).FirstOrDefault().Apartment.ID;


            try {
              
                
                ApplicationDbContext context = new ApplicationDbContext();
                ApplicationUser AppUser = new ApplicationUser();
                var RoleManager = new RoleManager<IdentityRole>(new RoleStore<IdentityRole>(context));
                var userManager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(context));
                // remove tenant from role
                userManager.RemoveFromRole(TenantID, "Tenant");
                //find tenant on the tenant table 
                 AspNetUsers aspnetuser = db.AspNetUsers.Find(TenantID);
                db.AspNetUsers.Remove(aspnetuser);
                var tn = db.Tenant.Find(TenantID);
                //remove tenant from the tenant table
                db.Tenant.Remove(tn);
                //save changes 
                db.SaveChanges();
                //load tenant applicationuser 
                AppUser = userManager.FindById(TenantID);
                //delete tenant applicationuser
                var result = userManager.Delete(AppUser);

              
               
            }
            catch (Exception e)
            {
                ViewBag.Message = e.Message;

            }

            var tenants = db.Tenant.Where(c => c.aptID == (int?)AID).Select(c => new
            {
                ID = c.ID,
                FirstName = c.FirstName,
                LastName = c.LastName,
                Phone = c.Phone,
                UserName = c.Username,
                CreatedDate = c.Created
            }).ToList();

            var mydata = Json(tenants);

            return new JsonResult { Data = mydata, JsonRequestBehavior = JsonRequestBehavior.AllowGet };
               
        }
Пример #34
0
        protected void grvUsers_RowDeleting(object sender, GridViewDeleteEventArgs e)
        {
            var id = grvUsers.DataKeys[e.RowIndex].Value.ToString();

            var userStore = new UserStore<IdentityUser>();
            var userManager = new UserManager<IdentityUser>(userStore);
            var user = userManager.FindById(id);

            if (user != null && user.UserName != "Admin")
            {
                userManager.Delete(user);
            }

            if (id == SharedClass.CurrentUser)
            {
                Response.Redirect("~/Login.aspx?Logout=true");
            }
        }
Пример #35
0
    public void removeSSAEktronMember(string UserPIN)
    {
        try
        {
            UserManager Usermanager = new UserManager();
            UserCriteria criteria = new UserCriteria(UserProperty.UserName, EkEnumeration.OrderByDirection.Ascending);

            criteria.AddFilter(UserProperty.UserName, CriteriaFilterOperator.EqualTo, UserPIN);

            List<UserData> UserList = Usermanager.GetList(criteria);
            long EktronUserID = UserList[0].Id;

            if (Ektron.Cms.Framework.Context.UserContextService.Current.IsLoggedIn)
            {
                Usermanager.Delete(EktronUserID);
                // add user to group MSBA Members
                //UserGroupManager UserGroupmanager = new UserGroupManager();
                //Add a User  to a UserGroup
                // UserGroupmanager.DeleteUser(1, newUserdata.Id);
            }
        }
        catch { }
    }
Пример #36
0
        public bool DeleteUser(string id)
        {
            var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
            var user = manager.FindById(id);

            var success=manager.Delete(user);
            if(success.Succeeded)
                return true;

            return false;
        }
Пример #37
0
 public ActionResult KullaniciSil(string id)
 {
     UserStore<HaberUser> userStore = new UserStore<HaberUser>(context);
     userManager = new UserManager<HaberUser>(userStore);
     if (id==null || id=="")
     {
         return RedirectToAction("KullaniciListesi");
     }
     else
     {
         var user = userManager.FindByName(id.Trim());
         if (user!=null)
         {
             userManager.Delete(user);
             context.SaveChanges();
             
         }
             return RedirectToAction("KullaniciListesi");
     }
 }
        public IHttpActionResult PostEmployee(Employee employee)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            var userStore = new UserStore<IdentityUser>();
            var manager = new UserManager<IdentityUser>(userStore);

            var user = new IdentityUser() { UserName = employee.Email, Email = employee.Email, PhoneNumber = employee.PrimaryMobile.ToString() };

            // TODO Environment Varialbe

            IdentityResult result = manager.Create(user, WebConfigurationManager.AppSettings["DefaultPassword"]);

            // IdentityResult result = manager.Create(user, Environment.GetEnvironmentVariable("DefaultPassword"));

            string[] roles =  { "", "", "", "", "ClientEmployee", "ClientAdmin", "OrgEmployee", "OrgManager", "SecondLevelManager" };
            int roleIndex = employee.EmpStatus;
            if (result.Succeeded)
            {
                employee.AuthUserId = user.Id;
                employee.ProfilePic = "0";
                employee.EmpStatus = 1;
                db.Employees.Add(employee);

                if (db.SaveChanges() != 1)
                {
                     manager.Delete(user);
                }
                else
                {
                    //manager.AddToRole(employee.AuthUserId, "ClientEmployee");
                    manager.AddToRole(employee.AuthUserId, roles[roleIndex]);
                }
            }
            return CreatedAtRoute("DefaultApi", new { id = employee.EmpId }, employee);
        }
Пример #39
0
 private void CleanUp(IdentityUser user, UserManager<IdentityUser, Guid> manager)
 {
     var result = manager.Delete(user);
     if (!result.Succeeded)
         throw new Exception("Failed to delete Identity");
 }
Пример #40
0
        public ActionResult deleteUser(string userID)
        {
            ajaxReturnData data = new ajaxReturnData();

            try
            {
                using (ApplicationDbContext DB = new ApplicationDbContext())
                {
                    ApplicationUser user = new ApplicationUser();

                    var store = new UserStore<ApplicationUser>(DB);
                    UserManager<ApplicationUser> um = new UserManager<ApplicationUser>(store);
                    user = um.FindById(userID);
                    if (user.UserName == "*****@*****.**")
                    {
                        data.statusCode = (int)statusCodes.fail;
                        data.message = "I'm sorry Dave, I'm afraid I can't do that";
                    }
                    else {
                        DB.UserLanguages.RemoveRange(DB.UserLanguages.Where(x => x.userID == userID));
                        data.message = "User '" + user.UserName + "' has become one with the void";
                        um.Delete(user);
                        data.statusCode = (int)statusCodes.successRun;
                    }
                    
                }

            }
            catch (Exception ex)
            {

                data.statusCode = (int)statusCodes.fail;
                data.message = "Failed to delete user; Error is: " + ex.Message;
            }



            return Json(data);
        }