/// <summary>
/// 删除用户。
/// </summary>
/// <param name="userDataObjects">需要删除的用户对象。</param>
public void DeleteUsers(List <User> userDataObjects)
{
if (userDataObjects == null)
{
throw new ArgumentNullException("userDataObjects");
}
foreach (var userDataObject in userDataObjects)
{
User user = null;
if (!IsEmptyGuidString(userDataObject.ID))
{
user = userRepository.Get(userDataObject.ID);
}
else if (!string.IsNullOrEmpty(userDataObject.UserName))
{
user = userRepository.GetUserByName(userDataObject.UserName);
}
else if (!string.IsNullOrEmpty(userDataObject.Email))
{
user = userRepository.GetUserByEmail(userDataObject.Email);
}
else
{
throw new ArgumentNullException("userDataObject", "Either ID, UserName or Email should be specified.");
}
var userRole = userRoleRepository.Find(Specification <UserRole> .Eval(ur => ur.UserID == user.ID));
if (userRole != null)
{
userRoleRepository.Delete(userRole);
}
userRepository.Delete(user);
}
Context.Commit();
}
public bool Delete(string id)
{
try
{
User user = _userRepository.Single(p => p.Id == id, null, include => include.Include(q => q.UserRole));
_userRoleRepository.Delete(user.UserRole);
_userRepository.Delete(user);
_userRepository.Save(RequestContext);
//delete customer
Customer customer = _accountRepository.All.Where(c => c.Id == id).Include(c => c.ProductReviews).Include(c => c.CustomerFeedbacks).FirstOrDefault();
if (customer != null)
{
_accountRepository.Delete(customer.CustomerFeedbacks);
_accountRepository.Delete(customer.CustomerFeedbacks);
_accountRepository.Delete(customer);
}
_accountRepository.Save(RequestContext);
_userInfoCache.RemoveUser(id);
_logger.LogInformation("Delete User {0} - ID: {1}", user.UserName, user.Id);
return(true);
}
catch (Exception e)
{
_logger.LogError(e, "Update user {0} failed", id);
return(false);
}
}
public async Task <bool> UpdateUser(UserDto dto)
{
int userId = dto.Id;
var entity = await _userRepository.QueryById(userId);
var pwd = entity.Password;
entity = _mapper.Map <User>(dto);
entity.Password = pwd;
entity.LastModificationTime = DateTime.Now;
await _userRepository.Update(entity);
if (!string.IsNullOrEmpty(dto.RoleIds))
{
//先删除已有的用户角色
await _userRoleRepository.Delete(t => t.UserId == userId);
var arr = dto.RoleIds.Split(",");
UserRole userRole = new UserRole();
foreach (var item in arr)
{
userRole.UserId = userId;
userRole.RoleId = Convert.ToInt32(item);
await _userRoleRepository.Add(userRole);
}
}
return(true);
}
public void UnassignRole(User user, Role role = null)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
Expression <Func <UserRole, bool> > specExpression = null;
if (role == null)
{
specExpression = ur => ur.UserId == user.Id;
}
else
{
specExpression = ur => ur.UserId == user.Id && ur.RoleId == role.Id;
}
UserRole userRole = _userRoleRepository.FirstOrDefault(specExpression);
if (userRole == null)
{
return;
}
_userRoleRepository.Delete(userRole);
}
/// <summary>
/// 修改用户信息
/// </summary>
/// <param name="sysUser"></param>
/// <returns></returns>
public async Task <bool> UpdateUser(SysUser sysUser)
{
var RoleIds = new List <Guid>();
var deletelist = await _userRoleRepository.GetAllListAsync(x => x.UserIdOrDepId == sysUser.Id);
if (!sysUser.RoleIds.IsNullOrEmpty())
{
RoleIds.AddRange(JsonConvert.DeserializeObject <List <Guid> >(sysUser.RoleIds));
}
var Rolelist = new List <SysUserRole>();
Rolelist.AddRange(RoleIds.Select(x => new SysUserRole
{
RoleId = x,
CreatedId = sysUser.UpdateId,
CreatedName = sysUser.UpdateName,
UserIdOrDepId = sysUser.Id,
}));
try
{
_unitofWork.BeginTransaction();
await _userRepositoty.UpdateAsync(sysUser);
await _userRoleRepository.Delete(deletelist);
await _userRoleRepository.InsertAsync(Rolelist);
_unitofWork.Commit();
return(true);
}
catch (Exception)
{
throw;
}
}
public void DeleteUserRole(UserRoleViewModel userRole)
{
UserRole entity = _userRoleRepository.GetById(userRole.Id);
_userRoleRepository.Delete(entity);
_unitOfWork.SaveChanges();
}
public bool SetRole(string userId, params string[] roleIds)
{
var all = _userRoleRepository.GetAll().Where(u => u.UserId == userId).ToList();
if (all.Count > 0 && roleIds.Length >= 0)
{
var remove = all.Where(u => !roleIds.Contains(u.RoleId)).ToList();
if (remove.Count > 0)
{
foreach (var userRole in remove)
{
_userRoleRepository.Delete(userRole);
}
}
}
foreach (var roleId in roleIds)
{
if (all.Exists(u => u.RoleId == roleId))
{
continue;
}
UserRole userRole = new UserRole()
{
RoleId = roleId,
UserId = userId
};
_userRoleRepository.Insert(userRole);
}
return(true);
}
public IHttpActionResult Delete([FromODataUri] System.Guid key)
{
logger.Trace("Call UserRolesController Delete");
UserRoleRepository.Delete(key);
return(Ok());
}
public Task RemoveFromRoleAsync(AbpUser user, string roleName)
{
return(Task.Factory.StartNew(
() =>
{
using (var uow = new UnitOfWorkScope())
{
var query =
from userRole in _userRoleRepository.GetAll()
join role in _roleRepository.GetAll() on userRole.RoleId equals role.Id
where userRole.UserId == user.Id && role.Name == roleName
select userRole;
var searchedUserRole = query.FirstOrDefault();
if (searchedUserRole == null)
{
return;
}
_userRoleRepository.Delete(searchedUserRole);
uow.Commit();
}
}));
}
[HttpDelete("eliminar/{id:int}")] // Metodo DELETE para eliminar elemento
public IActionResult Delete(int id)
{
var userRole = _userRoleRepository.Delete(id); // Eliminar elemento
var userRoleDto = _mapper.Map <UserRoleDto>(userRole); // Mapear entitidad a dto
return(Ok(userRoleDto));
}
/// <summary>
/// 将指定的用户从角色中移除。
/// </summary>
/// <param name="user">用户实体。</param>
/// <param name="role">角色实体，若为NULL，则表示从所有角色中移除。</param>
public void UnassignRole(User user, Role role = null)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
Expression <Func <UserRole, bool> > specExpression = null;
if (role == null)
{
specExpression = ur => ur.UserID == user.ID;
}
else
{
specExpression = ur => ur.UserID == user.ID && ur.RoleID == role.ID;
}
UserRole userRole = userRoleRepository.Find(Specification <UserRole> .Eval(specExpression));
if (userRole != null)
{
userRoleRepository.Delete(userRole);
repositoryContext.Commit();
}
}
public IActionResult Delete(int id)
{
User _userDb = _userRepository.GetSingle(id);
if (_userDb == null)
{
return(new NotFoundResult());
}
IEnumerable <Suggestion> _suggestions = _suggestionRepository.FindBy(a => a.CreatorId == id);
IEnumerable <UserRole> _userRoles = _userRoleRepository.FindBy(s => s.UserId == id);
foreach (var suggestion in _suggestions)
{
_suggestionRepository.Delete(suggestion);
}
foreach (var userRole in _userRoles)
{
_userRoleRepository.Delete(userRole);
}
_userRepository.Delete(_userDb);
_userRepository.Commit();
return(new NoContentResult());
}
public async Task RemoveFromRoleAsync(User user, string roleName, CancellationToken cancellationToken)
{
bool Predicate(UserRole userRole1) =>
userRole1.User.Id.Equals(user.Id);
var userRole = _userRoleRepository.GetAll(Predicate)
.FirstOrDefault(userRole2 => userRole2.Role.Name.ToUpper().Equals(roleName.ToUpper()));
_userRoleRepository.Delete(userRole);
}
public UpdateResult UpdateRoles(UserDto user)
{
var result = GetDefault <UpdateResult>();
var model = _userRepository.FindSingle(x => x.Id == user.Id);
if (model == null)
{
result.Message = "USE_NOT_EXIST";
result.StateCode = 0x00402;
return(result);
}
var list = model.UserRoles.ToList();
if (user.Roles != null)
{
foreach (var item in user.Roles)
{
if (!list.Exists(x => x.Role.Id == item.Id))
{
_userRoleRepository.Add(new UserRole {
RoleId = item.Id, UserId = model.Id
});
}
}
foreach (var item in list)
{
if (!user.Roles.Exists(x => x.Id == item.Id))
{
_userRoleRepository.Delete(item);
}
}
_userRoleRepository.Commit();
_userRepository.Commit();
}
result.IsSaved = true;
return(result);
}
public void UpdateUserInfo(UserInfoDomainModel payload)
{
var currentUser = _userRepository.GetById(payload.Id);
if (currentUser != null)
{
using (var scope = new TransactionScope())
{
currentUser.FirstName = payload.FirstName;
currentUser.LastName = payload.LastName;
currentUser.EmailAddress = payload.EmailAddress;
currentUser.DisplayName = payload.DisplayName;
currentUser.CountryId = payload.CountryId;
currentUser.ModifiedDate = DateTime.Now;
if (payload.ImageData != null)
{
if (currentUser.ProfileImage != null)
{
_imageRepository.DeleteImageById(currentUser.ProfileImage.GetValueOrDefault());
}
var newImage = new Core.Entities.Image()
{
Guid = Guid.NewGuid(),
ImageData = payload.ImageData,
CreatedDate = new DateTime()
};
_imageRepository.Insert(newImage);
_imageRepository.Save();
currentUser.ProfileImage = newImage.Guid;
}
if (payload.Roles.Any())
{
var currentRoles = _userRoleRepository.GetAllRoleByUserId(currentUser.Id);
currentRoles.ForEach(a => _userRoleRepository.Delete(a));
_userRoleRepository.Save();
payload.Roles.ForEach(a => _userRoleRepository.Insert(new Core.Entities.UserRole()
{
RoleId = a, UserId = currentUser.Id
}));
_userRoleRepository.Save();
}
_userRepository.Save();
scope.Complete();
}
}
}
public string DeleteRole(int UserRoleID)
{
try
{
_userRoleRepository.Delete(UserRoleID);
return("");
}
catch
{
return("fail");
}
}
public ActionResult Delete(long userId)
{
try
{
var result = userRoleRepository.Delete(userId);
return(Ok(new { success = true, data = result }));
}
catch (Exception ex)
{
return(Ok(new { success = false, errorMessage = ex.GetBaseException() }));
}
}
public Role UpdateRole(Role role)
{
var updatedRole = _roleRepository.GetAll().Where(item => item.Id == role.Id).FirstOrDefault();
Mapper.Map(role, updatedRole);
_roleRepository.Update(updatedRole);
if (role.UserIds != null && role.UserIds.Count > 0)
{
_userRoleRepository.Delete(userRole => userRole.RoleId == role.Id);
role.UserIds.ForEach(userId =>
{
UserRole userRole = new UserRole
{
UserId = userId,
RoleId = role.Id,
Creator = role.LastModifier
};
_userRoleRepository.Insert(userRole);
});
}
return(role);
}
/// <summary>
/// Delete all user permissions applied to a single entity
/// </summary>
/// <param name="userId">User identifier</param>
/// <returns>Return user permissions list</returns>
public Task <IList <ValidationResult> > DeletePermissionsOnEntity(IList <string> permissions, string entityId)
{
//Validazione argomenti
if (string.IsNullOrEmpty(entityId))
{
throw new ArgumentNullException(nameof(entityId));
}
IList <ValidationResult> validations = new List <ValidationResult>();
var permissionIds = _permissionRepository.FetchWithProjection(x => x.Id, x => permissions.Contains(x.Name));
//retrieve elements
var userPermissions = _userPermissionRepository.Fetch(x => x.EntityId == entityId && permissionIds.Contains(x.PermissionId));
foreach (var entityPermission in userPermissions)
{
_userPermissionRepository.Delete(entityPermission);
}
// get role permission on entity
var rolePermissions = _userRoleRepository.Fetch(x => x.EntityId == entityId);
var roleIds = rolePermissions.Select(x => x.RoleId);
var rolePermission =
_permissionRoleRepository
.FetchWithProjection(x => x.RoleId,
// filter by permissions
x => roleIds.Contains(x.RoleId) && permissionIds.Contains(x.PermissionId));
// delete every role with entityId and the role which contains the required permission
foreach (var userRole in rolePermissions.Where(x => rolePermission.Contains(x.RoleId)))
{
_userRoleRepository.Delete(userRole);
}
//Recupero i dati, commit ed uscita
return(Task.FromResult(validations));
}
public void RemoveRole(Guid id, Guid roleId)
{
if (null == _userRepository.Get(id))
{
throw new EntityValidationException("User does not exist.");
}
if (null == _roleRepository.Get(roleId))
{
throw new EntityValidationException("Role does not exist.");
}
_userRoleRepository.Delete(id, roleId);
}
/// <summary>
/// 添加、修改 User
/// </summary>
/// <param name="userModel"></param>
/// <param name="message"></param>
/// <returns></returns>
public bool SaveUser(UserModel userModel, out string message)
{
message = null;
var userEntity = new Sys_User
{
UserName = userModel.UserName,
Password = userModel.Password,
UserTrueName = userModel.UserTrueName,
CreateDate = DateTime.Now,
};
//添加用户
if (userModel.Id < 1)
{
_userRepository.Insert(userEntity);
_unitOfWork.Commit();
if (userEntity.Id < 1)
{
message = "添加用户失败";
return(false);
}
}
//修改操作
else
{
//删除用户角色关系
var userRoleIdArray = _userRoleRepository.Entities()
.Where(m => m.UserId == userModel.Id)
.Select(s => s.Id).ToList();
foreach (var roleId in userRoleIdArray)
{
_userRoleRepository.Delete(new Sys_User_Roles {
Id = roleId
});
}
}
var userRoles = new List <Sys_User_Roles>();
foreach (var roleId in userModel.Role)
{
userRoles.Add(new Sys_User_Roles {
UserId = userModel.Id, RoleId = roleId
});
}
//添加用户角色关系
_userRoleRepository.Insert(userRoles);
return(_unitOfWork.Commit() > 0);
}
public async Task <ActionResultResponse> Delete(string tenantId, string userId, string roleId)
{
// Check role exists in this tenant.
var isRoleExistsInTenant = await _roleRepository.CheckRoleExistsByTenant(tenantId, roleId);
if (!isRoleExistsInTenant)
{
return(new ActionResultResponse(-1, _sharedResourceService.GetString(ErrorMessage.NotHavePermission)));
}
var result = await _userRoleRepository.Delete(userId, roleId);
return(new ActionResultResponse(result, result <= 0 ? _sharedResourceService.GetString(ErrorMessage.SomethingWentWrong)
: _resourceService.GetString("Remove user role successful.")));
}
public bool RemoveFromRole(User user, string roleName)
{
IUserRoleRepository repo = _data_repository_factory.GetIdentityDataRepository <IUserRoleRepository>();
IIdentityRoleBusinessEngine role_be = _business_engine_factory.GetBusinessEngine <IIdentityRoleBusinessEngine>();
var role = role_be.FindByName(roleName);
UserRoleData ur = new UserRoleData()
{
RoleID = role.RoleId,
UserID = user.UserId
};
repo.Delete(ur);
return(true);
}
public async Task RemoveFromRoleAsync(TApplicationUser user, string roleName)
{
var roleEntity = await roleStore.FindByNameAsync(roleName);
if (roleEntity != null)
{
var roleId = roleEntity.Id;
var userId = user.Id;
var userRole = await userRoleRepository.Get(userId, roleId, session);
if (userRole != null)
{
await userRoleRepository.Delete(userId, roleId, session);
}
}
}
public Task RemoveFromRoleAsync(AbpUser user, string roleName)
{
return(Task.Factory.StartNew(
() =>
{
var userRole = _userRoleRepository.FirstOrDefault(
ur => ur.User.Id == user.Id && ur.Role.Name == roleName
);
if (userRole == null)
{
return;
}
_userRoleRepository.Delete(userRole.Id);
}));
}
public async Task RemoveFromRoleAsync(TUser user, string roleName, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var roleEntity = await roleStore.FindByNameAsync(roleName, cancellationToken);
if (roleEntity != null)
{
var roleId = roleEntity.Id;
var userId = user.Id;
var userRole = await userRoleRepository.Get(userId, roleId, session);
if (userRole != null)
{
await userRoleRepository.Delete(userId, roleId, session);
}
}
}
public bool GiveUserRoles(int userId, List <int> roleIdList)
{
var list = _userRoleRepository.GetAll(o => o.UserId == userId).ToList();
foreach (var userRole in list)
{
_userRoleRepository.Delete(userRole);
}
foreach (var roleId in roleIdList)
{
_userRoleRepository.Insert(new UserRoleRelation()
{
RoleId = roleId, UserId = userId
});
}
return(_unitOfWork.SaveChanges());
}
public async Task <ServiceResponseData> DeleteAsync(int id)
{
var responseData = new ServiceResponseData();
try
{
var entity = GetUserRoleEntity(id);
_userRoleRepository.Delete(entity);
_unitOfWork.Commit();
}
catch (Exception ex)
{
responseData.ErrorMessage = ex.ProcessException(_errorService);
responseData.IsSuccess = false;
}
return(await Task.FromResult(responseData));
}
public bool Delete(SessionContext sessionContext, int id)
{
try
{
return(_userRoleRepository.Delete(id));
}
catch (Exception ex)
{
_logger.LogException(new ExceptionLog
{
ExceptionDate = DateTime.Now,
ExceptionMsg = ex.Message,
ExceptionSource = ex.Source,
ExceptionType = "UserService",
FullException = ex.StackTrace
});
return(false);
}
}
public async Task <UserDto> UpdateUserAsync2(int userId, UserUpdateDto userUpdateDto)
{
using (var transaction = await _userRoleRepository.Context.Database.BeginTransactionAsync())
{
try
{
var user = await _userRepository.FindAsync(userId);
if (user == null)
{
throw new Exception($"user not found for userId = {userId}");
}
user.LastName = userUpdateDto.LastName;
var user2 = await _userRepository.UpdateAsync(user);
var userRole = _userRoleRepository.GetAll(x => x.UserId == userId);
_userRoleRepository.Delete(userRole);
foreach (var item in userUpdateDto.RoleDtos)
{
await _userRoleRepository.AddAsync(new UserRole
{
RoleId = item.Id.Value,
UserId = userId
});
}
//transaction.Commit();
return(user2.UserToUserDtoForResultUpdate());
}
catch (Exception ex)
{
//transaction.Rollback();
//Log Error ex.message;
throw ex;;
}
}
}
