/// <summary>
/// 创建实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task <OperationResult> CreateAsync(DTOUser entity)
{
//校验参数！=NULL
PublicHelper.CheckArgument(entity, "entity");
if (string.IsNullOrWhiteSpace(entity.Password) == true)
{
return(new OperationResult(OperationResultType.ParamError,
String.Format(CultureInfo.CurrentCulture,
Systems.SysResources.PasswordNullError)));
}
// 实体模型转换
var user = DtoMap.Map <SysUser>(entity);
// 校验实体
var validateResult = await Validator.ValidateAsync(user);
if (validateResult.ResultType != OperationResultType.Success)
{
return(validateResult);
}
user.PasswordHash = PasswordValidator.HashPassword(entity.Password);
// 添加到实体集合中
Repository.Insert(user, AutoSaved);
// 返回正确
return(new OperationResult(OperationResultType.Success));
}
/// <summary>
/// 创建实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task <OperationResult> CreateAsync(DTODepartment entity)
{
//校验参数！=NULL
PublicHelper.CheckArgument(entity, "entity");
// 实体模型转换
var Department = DtoMap.Map <SysDepartment>(entity);
// 校验实体
var validateResult = await Validator.ValidateAsync(Department);
if (validateResult.ResultType != OperationResultType.Success)
{
return(validateResult);
}
try
{
// 添加到实体集合中
Repository.Insert(Department, AutoSaved);
// 返回正确
return(new OperationResult(OperationResultType.Success));
}
catch (DataAccessException ex)
{
return(new OperationResult(OperationResultType.Error,
ex.Message));
}
}
/// <summary>
/// 获取指定页用户集合
/// </summary>
/// <param name="Index"></param>
/// <param name="limit"></param>
/// <param name="Order"></param>
/// <returns></returns>
public virtual Task <DTOPage <DTOUser> > UserPageListAsync(int skip, int limit, string Order)
{
PublicHelper.CheckArgument(Order, "Order");
PublicHelper.CheckArgument(skip, "Index", true);
PublicHelper.CheckArgument(limit, "Limit");
//获取记录数
var allCount = Repository.Entities.Count();
// 计算跳过记录数
if (skip < 0 || skip > allCount || limit < 1)
{
throw PublicHelper.ThrowBusinessException(
String.Format(CultureInfo.CurrentCulture,
Systems.SysResources.PageError,
"跳过记录数大于总数或每页数小于1"));
}
try
{
var result = new DTOPage <DTOUser>();
// 获取排序查询
var query = Repository.Entities.OrderBy(Order);
// 获取分页数据
var users = query.Skip(skip).Take(limit).ToList();
result.Total = allCount;
result.Data = DtoMap.Map <IEnumerable <DTOUser> >(users);
// 模型转换
return(Task.FromResult <DTOPage <DTOUser> >(result));
}
catch (DataAccessException ex)
{
throw PublicHelper.ThrowBusinessException(ex.Message, ex);
}
}
/// <summary>
/// 按照名称查询
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public virtual Task <DTODepartment> FindByNameAsync(string name)
{
PublicHelper.CheckArgument(name, "name");
var role = Repository.Entities.SingleOrDefault(m => m.Name.Equals(name));
if (role == null)
{
return(Task.FromResult <DTODepartment>(null));
}
return(Task.FromResult <DTODepartment>(DtoMap.Map <DTODepartment>(role)));
}
/// <summary>
/// 按照Email查询用户
/// </summary>
/// <param name="email"></param>
/// <returns></returns>
public virtual Task <DTOUser> FindByEmailAsync(string email)
{
PublicHelper.CheckArgument(email, "email");
var user = Repository.Entities.SingleOrDefault(m => m.Email.Equals(email));
if (user == null)
{
return(Task.FromResult <DTOUser>(null));
}
return(Task.FromResult <DTOUser>(DtoMap.Map <DTOUser>(user)));
}
/// <summary>
/// 按照ID查询用户
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public virtual Task <DTOUser> FindByIdAsync(string id)
{
PublicHelper.CheckArgument(id, "id");
var user = Repository.Entities.SingleOrDefault(m => m.Id.Equals(id));
if (user == null)
{
return(Task.FromResult <DTOUser>(null));
}
return(Task.FromResult <DTOUser>(DtoMap.Map <DTOUser>(user)));
}
/// <summary>
/// 按照用户名获取Email查询用户
/// </summary>
/// <param name="access"></param>
/// <returns></returns>
public virtual Task <DTOUser> FindUserAsync(string access)
{
PublicHelper.CheckArgument(access, "access");
var user = Repository.Entities.SingleOrDefault(m => m.Name == access || m.Email == access);
if (user == null)
{
return(Task.FromResult <DTOUser>(null));
}
var dtoUser = DtoMap.Map <DTOUser>(user);
return(Task.FromResult <DTOUser> (dtoUser));
}
/// <summary>
/// 根据用户名或Email，密码获取用户
/// </summary>
/// <param name="access"></param>
/// <param name="password"></param>
/// <returns></returns>
public virtual Task <DTOUser> FindUserAsync(string access, string password)
{
PublicHelper.CheckArgument(access, "access");
PublicHelper.CheckArgument(password, "password");
// 获取用户
var user = Repository.Entities.SingleOrDefault(m => m.Name == access || m.Email == access);
if (user == null)
{
return(Task.FromResult <DTOUser>(null));
}
//校验密码
if (PasswordValidator.VerifyHashedPassword(user.PasswordHash, password))
{
return(Task.FromResult <DTOUser>(DtoMap.Map <DTOUser>(user)));
}
return(Task.FromResult <DTOUser>(null));
}
/// <summary>
/// 获取指定页集合
/// </summary>
/// <param name="Index"></param>
/// <param name="Limit"></param>
/// <param name="Order"></param>
/// <returns></returns>
public virtual Task <IEnumerable <DTODepartment> > PageListAsync(int skip, int limit, string order, string parent = null)
{
PublicHelper.CheckArgument(order, "Order");
PublicHelper.CheckArgument(skip, "Skip", true);
PublicHelper.CheckArgument(limit, "Limit");
var queryAll = Repository.Entities;
if (string.IsNullOrWhiteSpace(parent) == false)
{
queryAll = queryAll.Where(d => d.Parent.Name.Equals(parent));
}
else
{
queryAll = queryAll.Where(d => d.Parent == null);
}
//获取记录数
var allCount = queryAll.Count();
// 计算跳过记录数
if (skip < 0 || skip > allCount || limit < 1)
{
throw PublicHelper.ThrowBusinessException(
String.Format(CultureInfo.CurrentCulture,
Systems.SysResources.PageError,
"跳过记录数大于总数或每页数小于1"));
}
try
{
// 获取排序查询
var query = queryAll.OrderBy(order);
// 获取分页数据
var users = query.Skip(skip).Take(limit).ToList();
// 模型转换
return(Task.FromResult <IEnumerable <DTODepartment> >(DtoMap.Map <IEnumerable <DTODepartment> >(users)));
}
catch (DataAccessException ex)
{
throw PublicHelper.ThrowBusinessException(ex.Message, ex);
}
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task <OperationResult> UpdateAsync(DTODepartment entity)
{
/// 更新角色信息
/// 考虑是否需要限制更改角色名称
/// 其他更新信息同样存在这个问题
//校验参数！=NULL
PublicHelper.CheckArgument(entity, "entity");
// 获取用户
var Department = Repository.Entities.SingleOrDefault(m => m.Name.Equals(entity.Name));
if (Department == null)
{
return(new OperationResult(OperationResultType.Warning,
String.Format(CultureInfo.CurrentCulture,
Systems.SysResources.DepartmentNotExist
, entity.Name)));
}
// 实体模型转换
Department = DtoMap.Map <DTODepartment, SysDepartment>(entity, Department);
// 校验实体
var validateResult = await Validator.ValidateAsync(Department);
if (validateResult.ResultType != OperationResultType.Success)
{
return(validateResult);
}
try
{
//更新实体
Repository.Update(Department, AutoSaved);
// 返回正确
return(new OperationResult(OperationResultType.Success));
}
catch (DataAccessException ex)
{
return(await Task.FromResult <OperationResult>(
new OperationResult(OperationResultType.Error, ex.Message)));
}
}
/// <summary>
/// 更新实体
/// </summary>
/// <param name="entity"></param>
/// <returns></returns>
public virtual async Task <OperationResult> UpdateAsync(DTOUser entity)
{
//校验参数！=NULL
PublicHelper.CheckArgument(entity, "entity");
// 获取用户
var user = Repository.Entities.SingleOrDefault(m => m.Name.Equals(entity.Name));
if (user == null)
{
return(new OperationResult(OperationResultType.Warning,
String.Format(CultureInfo.CurrentCulture,
Systems.SysResources.UserNoExist
, entity.Name)));
}
// 实体模型转换
user = DtoMap.Map <DTOUser, SysUser>(entity, user);
// 校验实体
var validateResult = await Validator.ValidateAsync(user);
if (validateResult.ResultType != OperationResultType.Success)
{
return(validateResult);
}
try
{
//更新实体
Repository.Update(user, AutoSaved);
}
catch (DataAccessException ex)
{
return(await Task.FromResult <OperationResult>(
new OperationResult(OperationResultType.Error, ex.Message)));
}
// 返回正确
return(new OperationResult(OperationResultType.Success));
}
