/// <summary>
/// 添加用户角色映射信息
/// </summary>
/// <param name="dto">用户角色映射信息输入DTO</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> CreateUserRoleMapAsync(TUserRoleMapInputDto dto)
{
dto.CheckNotNull("dto");
dto.ThrowIfTimeInvalid();
Expression <Func <TUserRoleMap, bool> > predicate = m => m.User.Id.Equals(dto.UserId) && m.Role.Id.Equals(dto.RoleId);
predicate = predicate.And(GetUserRoleMapUnexpireExpression(dto));
TUserRoleMap existMap = (await UserRoleMapRepository.GetByPredicateAsync(predicate)).FirstOrDefault();
if (existMap != null)
{
return(new OperationResult(OperationResultType.Error,
"“{0}{1}”存在的时间区间[{2}→{3}]包含当前时间段，不能重复添加"
.FormatWith(existMap.User.NickName, existMap.Role.Name, GetTimeString(existMap.BeginTime), GetTimeString(existMap.EndTime))));
}
TUserRoleMap map = dto.MapTo <TUserRoleMap>();
TUser user = UserRepository.GetByKey(dto.UserId);
if (user == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的用户信息不存在"));
}
map.User = user;
TRole role = RoleRepository.GetByKey(dto.RoleId);
if (role == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的角色信息不存在"));
}
map.Role = role;
await UserRoleMapRepository.InsertAsync(map);
return(OperationResult.Success);
}
/// <summary>
/// 设置用户的角色
/// </summary>
/// <param name="id">用户编号</param>
/// <param name="roleIds">角色编号集合</param>
/// <returns>业务操作结果</returns>
public async Task <OperationResult> SetUserRoles(int id, int[] roleIds)
{
User user = await UserRepository.GetByKeyAsync(id);
if (user == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的用户信息不存在"));
}
int[] existIds = UserRoleMapRepository.Entities.Where(m => m.User.Id == id).Select(m => m.Role.Id).ToArray();
int[] addIds = roleIds.Except(existIds).ToArray();
int[] removeIds = existIds.Except(roleIds).ToArray();
UserRoleMapRepository.UnitOfWork.TransactionEnabled = true;
foreach (int addId in addIds)
{
Role role = await RoleRepository.GetByKeyAsync(addId);
if (role == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的角色信息不存在"));
}
UserRoleMap map = new UserRoleMap()
{
User = user, Role = role
};
await UserRoleMapRepository.InsertAsync(map);
}
await UserRoleMapRepository.DeleteAsync(m => m.User.Id == id && removeIds.Contains(m.Role.Id));
return(await UserRoleMapRepository.UnitOfWork.SaveChangesAsync() > 0
? new OperationResult(OperationResultType.Success, "用户“{0}”指派角色操作成功".FormatWith(user.UserName))
: OperationResult.NoChanged);
}
/// <summary>
/// 添加用户角色映射信息
/// </summary>
/// <param name="dto">用户角色映射信息输入DTO</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> CreateUserRoleMapAsync(TUserRoleMapInputDto dto)
{
dto.CheckNotNull("dto");
dto.ThrowIfTimeInvalid();
Expression <Func <TUserRoleMap, bool> > predicate = m => m.User.Id.Equals(dto.UserId) && m.Role.Id.Equals(dto.RoleId);
TUserRoleMap map = await Task.Run(() => UserRoleMapRepository.TrackEntities.Where(predicate).FirstOrDefault());;
if (map != null)
{
return(new OperationResult(OperationResultType.Error,
"“{0}-{1}”的指派信息已存在，不能重复添加".FormatWith(map.User.NickName, map.Role.Name)));
}
map = dto.MapTo <TUserRoleMap>();
TUser user = UserRepository.GetByKey(dto.UserId);
if (user == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的用户信息不存在"));
}
map.User = user;
TRole role = RoleRepository.GetByKey(dto.RoleId);
if (role == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的角色信息不存在"));
}
map.Role = role;
await UserRoleMapRepository.InsertAsync(map);
return(OperationResult.Success);
}
/// <summary>
/// 删除用户角色映射信息
/// </summary>
/// <param name="id">用户角色映射编号</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> DeleteUserRoleMapAsync(TUserRoleMapKey id)
{
TUserRoleMap map = await UserRoleMapRepository.GetByKeyAsync(id);
if (map == null)
{
return(OperationResult.NoChanged);
}
await UserRoleMapRepository.DeleteAsync(map);
return(OperationResult.Success);
}
/// <summary>
/// 删除用户角色映射信息
/// </summary>
/// <param name="id">用户角色映射编号</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> DeleteUserRoleMapAsync(TUserRoleMapKey id)
{
TUserRoleMap map = await UserRoleMapRepository.GetByKeyAsync(id);
if (map == null)
{
return(OperationResult.NoChanged);
}
return(await UserRoleMapRepository.DeleteAsync(map) > 0
? new OperationResult(OperationResultType.Success, "用户角色映射信息删除成功")
: OperationResult.NoChanged);
}
/// <summary>
/// Removes the role for the user
/// </summary>
/// <param name="user"/><param name="roleName"/>
/// <returns/>
public virtual async Task RemoveFromRoleAsync(TUser user, string roleName)
{
user.CheckNotNull("user");
roleName.CheckNotNull("roleName");
TUserRoleMap map = (await UserRoleMapRepository.GetByPredicateAsync(m => m.User.Id.Equals(user.Id) && m.Role.Name.Equals(roleName)))
.FirstOrDefault();
if (map == null)
{
return;
}
await UserRoleMapRepository.DeleteAsync(map);
}
/// <summary>
/// 移除用户的角色
/// </summary>
/// <param name="user">用户信息</param>
/// <param name="roleName">角色名称</param>
/// <returns></returns>
public virtual async Task RemoveFromRoleAsync(TUser user, string roleName)
{
user.CheckNotNull("user");
roleName.CheckNotNull("roleName");
TUserRoleMap map = await Task.Run(() => UserRoleMapRepository.TrackEntities.Where(m => m.User.Id.Equals(user.Id) &&
m.Role.Name == roleName).FirstOrDefault());
if (map == null)
{
return;
}
await UserRoleMapRepository.DeleteAsync(map);
}
/// <summary>
/// Removes the role for the user
/// </summary>
/// <param name="user"/><param name="roleName"/>
/// <returns/>
public virtual async Task RemoveFromRoleAsync(TUser user, string roleName)
{
throw new NotSupportedException("用户存储不支持“用户-角色”指派业务的操作，请使用IUserRoleMapStore进行操作");
user.CheckNotNull("user");
roleName.CheckNotNull("roleName");
TUserRoleMap map = (await UserRoleMapRepository.GetByPredicateAsync(m => m.User.Id.Equals(user.Id) && m.Role.Name.Equals(roleName)))
.FirstOrDefault();
if (map == null)
{
return;
}
await UserRoleMapRepository.DeleteAsync(map);
}
/// <summary>
/// 删除用户信息信息
/// </summary>
/// <param name="ids">要删除的用户信息编号</param>
/// <returns>业务操作结果</returns>
public async Task <OperationResult> DeleteUsers(params int[] ids)
{
UserRepository.UnitOfWork.BeginTransaction();
List <int> mapIds = new List <int>();
foreach (var id in ids)
{
List <int> subIds = UserRoleMapRepository.TrackEntities.Where(x => x.User.Id == id).Select(x => x.Id).ToList();
if (subIds.Any())
{
mapIds.AddRange(subIds);
}
}
var result = await UserRoleMapRepository.DeleteAsync(mapIds);
if (result.ResultType == OperationResultType.Error)
{
return(result);
}
foreach (var id in ids)
{
User user = UserManager.Users.Where(x => x.Id == id).FirstOrDefault();
//var deleteResult = await UserManager.DeleteAsync(user);
//if (deleteResult.ToOperationResult().ResultType == OperationResultType.Error)
int deleteExtendCount = await UserExtendRepository.DeleteDirectAsync(user.Extend.Id);
if (deleteExtendCount < 0)
{
return(new OperationResult(OperationResultType.Error, $"删除用户{user.UserName}扩展信息失败！"));
}
int count = await UserRepository.DeleteDirectAsync(user.Id);
if (count <= 0)
{
return(new OperationResult(OperationResultType.Error, $"删除用户{user.UserName}信息失败！"));
}
}
UserRepository.UnitOfWork.Commit();
return(new OperationResult(OperationResultType.Success, $"删除用户成功！"));;
}
/// <summary>
/// Adds a user to a role
/// </summary>
/// <param name="user"/><param name="roleName"/>
/// <returns/>
public virtual async Task AddToRoleAsync(TUser user, string roleName)
{
user.CheckNotNull("user");
roleName.CheckNotNull("roleName");
bool exists = UserRoleMapRepository.Entities.Any(m => m.User.Id.Equals(user.Id) && m.Role.Name.Equals(roleName));
if (exists)
{
return;
}
TRole role = (await RoleRepository.GetByPredicateAsync(m => m.Name.Equals(roleName))).FirstOrDefault();
if (role == null)
{
throw new InvalidOperationException("指定名称的角色信息不存在");
}
TUserRoleMap map = new TUserRoleMap()
{
User = user, Role = role
};
await UserRoleMapRepository.InsertAsync(map);
}
/// <summary>
/// 给用户添加角色
/// </summary>
/// <param name="user">用户信息</param>
/// <param name="roleName">角色名称</param>
/// <returns></returns>
public virtual async Task AddToRoleAsync(TUser user, string roleName)
{
user.CheckNotNull("user");
roleName.CheckNotNull("roleName");
bool exist = await UserRoleMapRepository.CheckExistsAsync(m => m.User.Id.Equals(user.Id) && m.Role.Name == roleName);
if (exist)
{
return;
}
TRole role = await Task.Run(() => RoleRepository.TrackEntities.Where(m => m.Name == roleName).FirstOrDefault());
if (role == null)
{
throw new InvalidOperationException("名称为“{0}”的角色信息不存在".FormatWith(roleName));
}
TUserRoleMap map = new TUserRoleMap()
{
User = user, Role = role
};
await UserRoleMapRepository.InsertAsync(map);
}
/// <summary>
/// 编辑用户角色映射信息
/// </summary>
/// <param name="dto">用户角色映射信息输入DTO</param>
/// <returns>业务操作结果</returns>
public virtual async Task <OperationResult> UpdateUserRoleMapAsync(TUserRoleMapInputDto dto)
{
dto.CheckNotNull("dto");
dto.ThrowIfTimeInvalid();
Expression <Func <TUserRoleMap, bool> > predicate = m => m.User.Id.Equals(dto.UserId) && m.Role.Id.Equals(dto.RoleId);
TUserRoleMap map = UserRoleMapRepository.TrackEntities.Where(predicate).FirstOrDefault();
if (map != null && !map.Id.Equals(dto.Id))
{
return(new OperationResult(OperationResultType.Error,
"“{0}-{1}”的指派信息已存在，不能重复添加".FormatWith(map.User.NickName, map.Role.Name)));
}
if (map == null || !map.Id.Equals(dto.Id))
{
map = await UserRoleMapRepository.GetByKeyAsync(dto.Id);
}
map = dto.MapTo(map);
if (map.User == null || !map.User.Id.Equals(dto.UserId))
{
TUser user = UserRepository.GetByKey(dto.UserId);
if (user == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的用户信息不存在"));
}
map.User = user;
}
if (map.Role == null || !map.Role.Id.Equals(dto.RoleId))
{
TRole role = RoleRepository.GetByKey(dto.RoleId);
if (role == null)
{
return(new OperationResult(OperationResultType.QueryNull, "指定编号的角色信息不存在"));
}
map.Role = role;
}
return(await UserRoleMapRepository.UpdateAsync(map) > 0
? new OperationResult(OperationResultType.Success, "用户“{0}”与角色“{1}”的映射信息更新成功".FormatWith(map.User.UserName, map.Role.Name))
: OperationResult.NoChanged);
}
/// <summary>
/// 根据指定用户添加用户角色映射信息
/// </summary>
/// <param name="dtos">要添加的用户角色映射信息DTO信息</param>
/// <returns>业务操作结果</returns>
public async Task <OperationResult> AddUserRoleMapsByUser(params UserRoleMapDto[] dtos)
{
dtos.CheckNotNull("dtos");
var uid = dtos[0].UserId;
var list = UserRoleMaps.Where(c => c.UserId == uid).Select(m => new UserRoleMapDto
{
Id = m.Id,
UserId = m.UserId,
RoleId = m.RoleId
}).ToList();
//删除移除的用户
var removeItems = list.Except(dtos, EqualityHelper <UserRoleMapDto> .CreateComparer(m => m.RoleId + m.UserId)).Select(m => m.Id).ToArray();
OperationResult result = await DeleteUserRoleMaps(removeItems);
//添加新增的用户
var items = dtos.Except(list, EqualityHelper <UserRoleMapDto> .CreateComparer(m => m.RoleId + m.UserId)).ToArray();
if (items.Count() > 0)
{
result = await Task.FromResult(UserRoleMapRepository.Insert(items));
}
return(result);
}
/// <summary>
/// 检查用户角色映射信息信息是否存在
/// </summary>
/// <param name="predicate">检查谓语表达式</param>
/// <param name="id">更新的用户角色映射信息编号</param>
/// <returns>用户角色映射信息是否存在</returns>
public Task <bool> CheckUserRoleMapExists(Expression <Func <UserRoleMap, bool> > predicate, int id = 0)
{
return(UserRoleMapRepository.CheckExistsAsync(predicate, id));
}
/// <summary>
/// 删除用户角色映射信息
/// </summary>
/// <param name="ids">要删除的用户角色映射编号</param>
/// <returns>业务操作结果</returns>
public async Task <OperationResult> DeleteUserRoleMaps(params int[] ids)
{
OperationResult result = UserRoleMapRepository.Delete(ids, null);
return(await Task.FromResult(result));
}
