public async Task <ActionResult> DeleteConfirmed(int id)
        {
            try
            {
                var userToDelete = await _userRepo.Get(id);

                var identityUser = await UserIdentityManager.
                                   GetUserFromModelId(userToDelete.ID);

                if (identityUser != null &&
                    userToDelete != null)
                {
                    userToDelete.RoleID = RoleNames.ARCHIVED;

                    var result = await UserIdentityManager.Changerole
                                     (identityUser, userToDelete.RoleID);

                    userToDelete.IsActive = false;
                    var res = await _userRepo.Delete(userToDelete);

                    if (res == 0)
                    {
                        var user = await _userRepo.Get(id);

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

                        model.InputModel = user;

                        ModelState.AddModelError
                            (string.Empty, "Agent can't be deleted.");

                        return(View("Delete", model));
                    }
                }
                else
                {
                    return(HttpNotFound());
                }
            }
            catch (Exception ex)
            {
                ModelState.AddModelError
                    (string.Empty, ex.Message);

                var user = await _userRepo.Get(id);

                model.InputModel = user;

                return(View("Delete", model));
            }
            return(RedirectToAction("Index"));
        }
        public async Task <ActionResult> Edit(OperatingUser inputModel)
        {
            if (ModelState.IsValid)
            {
                try
                {
                    var currentLoggedUserId = User.Identity.GetUserId();

                    var currentLoggedUserRes = await UserIdentityManager.GetUserById
                                                   (currentLoggedUserId);


                    var userMappedRes = inputModel;
                    userMappedRes.UserUpdatorId = currentLoggedUserRes.registeredUser.ID;
                    userMappedRes.UpdatedDate   = DateTime.Now;

                    var identityUser = await UserIdentityManager
                                       .GetUserFromModelId(userMappedRes.ID);

                    if (identityUser != null)
                    {
                        var result = await UserIdentityManager.Changerole
                                         (identityUser, userMappedRes.RoleID);

                        userMappedRes.IsActive = true;

                        if (userMappedRes.RoleID != RoleNames.AGENT)
                        {
                            userMappedRes.IsVerified = true;
                        }



                        var res = await _userRepo.Update(userMappedRes);

                        if (res > 0)
                        {
                            return(RedirectToAction("Details",
                                                    new { id = userMappedRes.ID }));
                        }
                        else
                        {
                            model.InputModel = inputModel;
                            model.rolesList  = await UserIdentityManager.GetRoles();

                            return(View("Edit", model));
                        }
                    }
                }
                catch (Exception ex)
                {
                    model.InputModel = inputModel;
                    model.rolesList  = await UserIdentityManager.GetRoles();

                    ModelState.AddModelError(string.Empty, ex.Message);

                    return(View("Edit", model));
                }
            }
            model.InputModel = inputModel;
            model.rolesList  = await UserIdentityManager.GetRoles();

            return(View("Edit", model));
        }