/// <summary>
/// 保存主菜单的前置验证
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void SavingCheck(MenuMainInfo info, TokenLogonInfo logonInfo)
{
if (string.IsNullOrWhiteSpace(info.Name))
{
ApiException.ThrowBadRequest("主菜单名称不能为空");
}
if (info.Index <= 0)
{
info.Index = 10;
}
if (info.Type == MenuType.None)
{
info.Type = DefaultMenuType;
}
foreach (var sub in info.SubMenu)
{
if (string.IsNullOrWhiteSpace(sub.Name))
{
ApiException.ThrowBadRequest("子菜单名称不能为空");
}
if (string.IsNullOrWhiteSpace(sub.Link))
{
ApiException.ThrowBadRequest("子菜单的地址不能为空");
}
if (sub.Index <= 0)
{
sub.Index = 10;
}
if (sub.Type == MenuType.None)
{
sub.Type = DefaultMenuType;
}
}
}
/// <summary>
/// 保存的校验
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void SavingCheck(IndustryCategoryInfo info, TokenLogonInfo logonInfo)
{
//数据验证
if (string.IsNullOrWhiteSpace(info.Name))
{
throw ApiException.BadRequest("行业分类名称不能为空");
}
//检查行业名称不能重复
var query = _Dal.Queryable().Where(e => !string.IsNullOrEmpty(e.Name) && e.Name.Equals(info.Name) && e.IsDelete == false);
if (info.IsEmpty)
{
if (query.Count() > 0)
{
throw ApiException.BadRequest("行业分类不能重复");
}
}
else
{
string id = info.Id.ToString();
foreach (var item in query)
{
if (item.Id.ToString() != id)
{
throw ApiException.BadRequest("行业分类不能重复");
}
}
}
}
/// <summary>
///
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void Saving(MenuMainInfo info, TokenLogonInfo logonInfo)
{
if (info.Type == MenuType.None)
{
info.Type = DefaultMenuType;
}
}
/// <summary>
/// 禁用配置
/// </summary>
/// <param name="id"></param>
/// <param name="logonInfo"></param>
/// <returns></returns>
public ResultView Disable(string id, TokenLogonInfo logonInfo)
{
var info = _SearchById(id);
info.IsOpen = false;
return(Update(info, logonInfo));
}
/// <summary>
/// 保存验证处理
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void SavingCheck(IndustryInfo info, TokenLogonInfo logonInfo)
{
//行业名称不能为空
if (string.IsNullOrWhiteSpace(info.Name))
{
throw ApiException.BadRequest("行业名称不能为空");
}
//行业名称不能重复
var query = _Dal.Queryable().Where(e => e.Name == info.Name).ToList();
if (!info.IsEmpty)//修改时过滤本身的ID
{
string id = info.Id.ToString();
for (int i = 0; i < query.Count; i++)
{
if (query[i].Id.ToString() == id)
{
query.RemoveAt(i);
break;
}
}
}
if (query.Count() > 0)
{
throw ApiException.BadRequest("行业名称不能重复");
}
}
/// <summary>
/// 保存的前置校验
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void SavingCheck(EmailConfigInfo info, TokenLogonInfo logonInfo)
{
#region 验证非空
if (string.IsNullOrWhiteSpace(info.LocalMailFromName))
{
throw ApiException.BadRequest("邮箱标题不允许为空");
}
if (string.IsNullOrWhiteSpace(info.LocalMailFromMail))
{
throw ApiException.BadRequest("邮箱不能为空");
}
if (string.IsNullOrWhiteSpace(info.LocalMailSMTP))
{
throw ApiException.BadRequest("SMTP 服务器不能为空");
}
if (string.IsNullOrWhiteSpace(info.LocalMailSMTPPort))
{
throw ApiException.BadRequest("SMTP 服务器端口不能为空");
}
if (string.IsNullOrWhiteSpace(info.LocalMailUserName))
{
throw ApiException.BadRequest("邮箱的用户名不能为空");
}
if (string.IsNullOrWhiteSpace(info.LocalMailPwd))
{
throw ApiException.BadRequest("邮箱的密码或授权密钥不能为空");
}
#endregion
}
/// <summary>
/// 设置配置信息
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
public void Setting(TencentConfigInfo info, TokenLogonInfo logonInfo)
{
var old = Load(logonInfo);
old.AppId = info.AppId;
old.AppKey = info.AppKey;
this.Update(info, logonInfo);
}
/// <summary>
/// 保存的校验
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void SavingCheck(DepartmentInfo info, TokenLogonInfo logonInfo)
{
//数据验证
if (string.IsNullOrWhiteSpace(info.Name))
{
throw ApiException.BadRequest("请指定部门的名称");
}
}
/// <summary>
/// 保存后置处理
/// </summary>
/// <param name="newEntity"></param>
/// <param name="oldEntity"></param>
/// <param name="logonInfo"></param>
public void OnUpdated(DepartmentInfo newEntity, DepartmentInfo oldEntity, TokenLogonInfo logonInfo)
{
IServiceProvider _ServiceProvider = _services.BuildServiceProvider();
// 部门的主管修改后，需要修改企业的申请
// CompanyApplyService companyApplyService = (CompanyApplyService)_ServiceProvider.GetService(typeof(CompanyApplyService));
// if (companyApplyService != null)
// {
// companyApplyService.OnDepartmentChange(newEntity, oldEntity, logonInfo);
// }
}
/// <summary>
/// 加载配置信息
/// </summary>
/// <param name="logonInfo"></param>
/// <returns></returns>
public TencentConfigInfo Load(TokenLogonInfo logonInfo)
{
var info = _Dal.Queryable().FirstOrDefault();
if (info == null || info.IsEmpty)
{
return(InitConfig(logonInfo));
}
return(info);
}
/// <summary>
/// 初始化配置信息
/// </summary>
/// <param name="logonInfo"></param>
public TencentConfigInfo InitConfig(TokenLogonInfo logonInfo)
{
TencentConfigInfo info = new TencentConfigInfo {
AppId = 1400059775, AppKey = "eaa15e15da52a7892bf91277f66b3f63"
};
_Dal.Drop();
this.Create(info, logonInfo);
return(info);
}
/// <summary>
/// 角色更新的后置处理
/// </summary>
/// <param name="roleInfo">新的角色信息</param>
/// <param name="oldInfo">旧的角色信息</param>
/// <param name="logonInfo"></param>
internal static void OnRoleUpdated(RoleInfo roleInfo, RoleInfo oldInfo, TokenLogonInfo logonInfo)
{
if (roleInfo.Name != oldInfo.Name)
{
// 更新员工信息
ThreadPool.QueueUserWorkItem(h =>
{
EmployeeDAL dal = ServiceLoader.GetService <EmployeeDAL>();
// 更新部门信息
dal.UpdateRoleInfo(roleInfo);
});
}
}
/// <summary>
/// 解析Excel文件并将其数据持久化
/// </summary>
/// <param name="file"></param>
/// <param name="logonInfo"></param>
/// <returns></returns>
public DataImportIndexView AnalyzFile(FileNameView file, TokenLogonInfo logonInfo)
{
// 创建导入的主索引数据
DataImportIndexInfo main = new DataImportIndexInfo()
{
ImportFile = file,
Batch = GetBatch(), // file.FileName.Replace($".{file.FileExtName}", ""),
DataType = DataType,
CreateDate = DateTime.Now,
CreaterId = logonInfo.Id,
CreaterName = logonInfo.Name,
UpdateDate = DateTime.Now,
UpdaterId = logonInfo.Id,
UpdaterName = logonInfo.Name,
ProcessState = ProcessState.Edit,
IsDelete = false,
Count = 0,
Current = 0,
IsComplete = false
};
// 读取Excel文件中的数据
List <T> excelData = ExcelHelper.Import <T>(main.ImportFile.DiskFileFullName);
// 按Excel中的行号排序
excelData = excelData.OrderBy(e => e.RowIndex).ToList();
// 完善提交的数据信息
foreach (var item in excelData)
{
item.Batch = main.Batch;
item.ImportState = ImportState.None;
item.CreateDate = DateTime.Now;
item.CreaterId = logonInfo.Id;
item.CreaterName = logonInfo.Name;
item.UpdateDate = DateTime.Now;
item.UpdaterId = logonInfo.Id;
item.UpdaterName = logonInfo.Name;
}
//解析导入的数据信息
List <T> importList = AnalyzeImportList(excelData);
// 持久化导入索引信息
main.Count = excelData.Count;
main.Current = 1;
mainDal.InsertObject(main);
// 持久化导入数据
detailDal.InsertRange(excelData);
// 返回导入的索引查看对象
return(AutoMapper.Mapper.Map <DataImportIndexView>(main));
}
/// <summary>
/// 判断当前用户是否为管理员
/// </summary>
/// <param name="logonInfo"></param>
/// <returns></returns>
static public bool IsAdminRole(this TokenLogonInfo logonInfo)
{
RoleService roleService = ServiceLoader.GetService <RoleService>();
if (roleService == null)
{
return(false);
}
var roleInfo = roleService._SearchById(logonInfo.RoleId);
if (roleInfo != null && roleInfo.Name.Contains("管理员"))
{
return(true);
}
return(false);
}
/// <summary>
/// 保存前，完善数据
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void Saving(DepartmentInfo info, TokenLogonInfo logonInfo)
{
//完善上级部门名称
if (!string.IsNullOrEmpty(info.ParentId))
{
var parent = _SearchById(info.ParentId);
info.ParentName = parent.Name;
info.ParentsIds = parent.ParentsIds;
if (!info.IsEmpty)
{
info.ParentsIds.Add(info.Id.ToString());
}
}
else
{
info.ParentId = string.Empty;
info.ParentName = string.Empty;
if (info.IsEmpty)
{
info.ParentsIds = new List <string>();
}
else
{
info.ParentsIds = new List <string>()
{
info.Id.ToString()
};
}
}
//完善部门主管信息
//if (!string.IsNullOrEmpty(info.ManageId))
//{
// EmployeeService employeeService = ServiceLoader.GetService<EmployeeService>();
// var employee = employeeService._SearchById(info.ManageId);
// info.ManageName = employee.Name;
//}
//else
//{
// info.ManageName = string.Empty;
//}
// 上级部门不能是自己的子部门
if (!string.IsNullOrEmpty(info.ParentId) && GetSubDepartmentId(info.Id.ToString()).Contains(info.ParentId))
{
throw ApiException.BadRequest("上级部门不能是" + info.Name + "的子部门");
}
}
/// <summary>
/// 保存的前置操作
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void Saving(EmployeeInfo info, TokenLogonInfo logonInfo)
{
//设置员工状态
info.State = UserState.Enable;
info.ProcessState = ProcessState.Enable;
//完善数据
//1、完善部门信息
if (info.Department != null && !string.IsNullOrWhiteSpace(info.Department.Id))
{
string depId = info.Department.Id;
if (!string.IsNullOrWhiteSpace(depId))
{
DepartmentInfo depInfo = _DepDal.SearchById(depId);
if (depInfo == null)
{
throw ApiException.BadRequest("选择的部门信息不存在，请刷新页面再尝试");
}
info.Department = new SelectView()
{
Id = depId, Name = depInfo.Name, Code = depInfo.Code
};
info.ParentDepartment.Id = depInfo.ParentId;
info.ParentDepartment.Name = depInfo.Name;
info.ParentDepartment.Ids = depInfo.ParentsIds;
}
}
//2、完善角色信息
if (info.Role != null && !string.IsNullOrWhiteSpace(info.Role.Id))
{
string roleId = info.Role.Id;
if (!string.IsNullOrWhiteSpace(roleId))
{
RoleInfo role = _RoleDal.SearchById(roleId);
if (role == null)
{
throw ApiException.BadRequest("选择的角色信息不存在，请刷新页面再尝试");
}
info.Role = new SelectView()
{
Id = roleId, Name = role.Name, Code = ""
};
}
}
}
/// <summary>
/// 设置导入完成
/// </summary>
/// <param name="batch"></param>
/// <param name="failFile"></param>
/// <param name="logonInfo"></param>
/// <returns></returns>
public void SetComplete(string batch, FileNameView failFile, TokenLogonInfo logonInfo)
{
// 获取主表数据
var main = SearchMainByBatch(batch);
// 设置主表数据
main.ProcessState = ProcessState.Complete;
main.IsComplete = true;
main.UpdateDate = DateTime.Now;
main.UpdaterId = logonInfo.Id;
main.UpdaterName = logonInfo.Name;
main.FailImportFile = failFile;
// 生成导入失败的Excel文件
// 异步生成导入失败的Excel文件
ThreadPool.QueueUserWorkItem(h =>
{
GenerateFailFile(main);
});
// 持久化设置的主表数据
mainDal.UpdateObject(main);
}
/// <summary>
/// 保存的校验
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void SavingCheck(EmployeeInfo info, TokenLogonInfo logonInfo)
{
// 处理角色的验证
if (RequiredRole)
{
if (info.Role == null)
{
throw ApiException.BadRequest("请指定用户的角色");
}
}
// 处理部门的验证
if (RequiredDepartment)
{
if (info.Department == null)
{
throw ApiException.BadRequest("请指定用户的部门");
}
}
// 验证登录账号
if (info.IsEmpty)
{
if (_Dal.Queryable().Where(e => e.LogonAccount == info.LogonAccount).Count() > 0)
{
throw ApiException.BadRequest("登陆账号已存在，无法新增用户");
}
}
else
{
foreach (var item in _Dal.Queryable().Where(e => e.LogonAccount == info.LogonAccount))
{
if (item.Id.ToString() != info.Id.ToString())
{
throw ApiException.BadRequest("登陆账号已存在，无法修改");
}
}
}
}
/// <summary>
/// 更新的后置操作
/// </summary>
/// <param name="info"></param>
/// <param name="old"></param>
/// <param name="logonInfo"></param>
protected override void Updated(DepartmentInfo info, DepartmentInfo old, TokenLogonInfo logonInfo)
{
// 只针对部门名称进行修改
if (info.Name != old.Name)
{
ThreadPool.QueueUserWorkItem(h =>
{
// 如果当前部门名称改变，会同时修改其子部门下的关联上级部门名称
((DepartmentDAL)_Dal).UpdateParentsDepartmentName(info);
});
}
// 如果上级部门改变，同时修改下级的上级列表
if (info.ParentId != old.ParentId)
{
ThreadPool.QueueUserWorkItem(h =>
{
foreach (var dep in _Dal.Queryable().Where(e => e.ParentId == info.Id.ToString()))
{
Update(dep, logonInfo);
}
});
}
}
/// <summary>
/// 员工更新的后置处理
/// </summary>
/// <param name="newEentity"></param>
/// <param name="oldEntity"></param>
/// <param name="logonInfo"></param>
public void OnUpdated(EmployeeInfo newEentity, EmployeeInfo oldEntity, TokenLogonInfo logonInfo)
{
}
/// <summary>
/// 部门信息的保存验证处理
/// </summary>
/// <param name="entity"></param>
/// <param name="logonInfo"></param>
public void OnSavingCheck(DepartmentInfo entity, TokenLogonInfo logonInfo)
{
// 如果验证不通过，可以通过抛出异常的形式终止保存操作，系统会将异常信息按Json形式返回到调用端。
// ApiException.ThrowBadRequest("部门信息自定义异常信息");
}
/// <summary>
/// 新增后置操作
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void Created(DepartmentInfo info, TokenLogonInfo logonInfo)
{
info.ParentsIds.Add(info.Id.ToString());
_Dal.UpdateObject(info);
}
/// <summary>
/// 部门更新的后置处理
/// </summary>
/// <param name="depInfo">新的部门信息</param>
/// <param name="oldInfo">旧的部门信息</param>
/// <param name="logonInfo"></param>
internal static void OnDepartmentUpdated(DepartmentInfo depInfo, DepartmentInfo oldInfo, TokenLogonInfo logonInfo)
{
// 更新员工信息
ThreadPool.QueueUserWorkItem(h =>
{
EmployeeService service = ServiceLoader.GetService <EmployeeService>();
// 更新所有的员工信息
service.UpdateByDepartmentInfo(depInfo, oldInfo);
});
}
/// <summary>
///
/// </summary>
/// <param name="info"></param>
/// <param name="logon"></param>
static public void Test2(DepartmentInfo info, TokenLogonInfo logon)
{
//var a = "abc";
}
/// <summary>
/// 员工保存的后置处理
/// </summary>
/// <param name="entity"></param>
/// <param name="logonInfo"></param>
public void OnSaved(EmployeeInfo entity, TokenLogonInfo logonInfo)
{
}
/// <summary>
///
/// </summary>
/// <param name="logonInfo"></param>
/// <returns></returns>
public void Logout(TokenLogonInfo logonInfo)
{
OnLogout?.Invoke(logonInfo);
}
/// <summary>
/// 导入数据的具体操作
/// </summary>
/// <param name="import"></param>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected virtual void Import(T import, Info info, TokenLogonInfo logonInfo)
{
}
/// <summary>
/// 按数据ID执行导入操作，返回导入结果及失败原因
/// </summary>
/// <param name="importId"></param>
/// <param name="logonInfo"></param>
/// <returns></returns>
public DataImportDetailResult ImportSingle(string importId, TokenLogonInfo logonInfo)
{
#region 获取导入数据
// 获取需要导入的数据
T import = detailDal.SearchById(importId);
if (import == null)
{
return(new DataImportDetailResult
{
Id = importId,
ImportState = ImportState.Fail,
ImportResult = "导入失败",
FailureReason = "导入数据的ID错误。id:" + importId
});
}
#endregion
// 数据转换
Info info;
try
{
info = Tran(import);
info.CreateDate = DateTime.Now;
info.CreaterId = logonInfo.Id;
info.CreaterName = logonInfo.Name;
info.UpdateDate = DateTime.Now;
info.UpdaterId = logonInfo.Id;
info.UpdaterName = logonInfo.Name;
}
catch (Exception ex)
{
return(new DataImportDetailResult
{
Id = importId,
RowIndex = import.RowIndex,
Batch = import.Batch,
ImportState = ImportState.Fail,
ImportResult = "导入失败",
FailureReason = ex.Message
});
}
#region 检查数据
// 检查导入的数据
ImportCheck(import, info);
if (import.ImportState == ImportState.Fail)
{
import.UpdateDate = DateTime.Now;
import.UpdaterId = logonInfo.Id;
import.UpdaterName = logonInfo.Name;
detailDal.UpdateObject(import);
return(new DataImportDetailResult
{
Id = importId,
RowIndex = import.RowIndex,
Batch = import.Batch,
ImportState = ImportState.Fail,
ImportResult = "导入失败",
FailureReason = import.FailureReason
});
}
// 排重的检查 需要重写排重方法
RepeatCheck(import, info);
if (import.ImportState == ImportState.Fail)
{
import.UpdateDate = DateTime.Now;
import.UpdaterId = logonInfo.Id;
import.UpdaterName = logonInfo.Name;
detailDal.UpdateObject(import);
return(new DataImportDetailResult
{
Id = importId,
RowIndex = import.RowIndex,
Batch = import.Batch,
ImportState = ImportState.Fail,
ImportResult = "导入失败",
FailureReason = import.FailureReason
});
}
#endregion
// 保存导入的数据到对应的数据集合中
try
{
// 保存导入后的对象信息
info.Id = MongoDB.Bson.ObjectId.Empty;
Import(import, info, logonInfo);
if (String.IsNullOrEmpty(import.ImportResult))
{
import.ImportResult = "导入成功";
}
// 保存导入前的对象信息 记录保存成功
import.ImportState = ImportState.Complete;
import.UpdateDate = DateTime.Now;
import.UpdaterId = logonInfo.Id;
import.UpdaterName = logonInfo.Name;
detailDal.UpdateObject(import);
// 更新主表进度
var main = mainDal.Queryable().Where(e => e.Batch == import.Batch).FirstOrDefault();
if (main != null)
{
main.Current++;
mainDal.UpdateObject(main);
}
return(new DataImportDetailResult
{
Id = importId,
RowIndex = import.RowIndex,
Batch = import.Batch,
ImportState = ImportState.Complete,
ImportResult = "导入成功",
});
}
catch (Exception ex)
{
//保存导入前的对象信息 记录导入失败及出错原因
import.ImportState = ImportState.Fail;
import.FailureReason = ex.Message;
import.UpdateDate = DateTime.Now;
import.UpdaterId = logonInfo.Id;
import.UpdaterName = logonInfo.Name;
import.FailureReason = ex.Message;
import.ImportResult = "导入失败";
detailDal.UpdateObject(import);
return(new DataImportDetailResult
{
Id = importId,
RowIndex = import.RowIndex,
Batch = import.Batch,
ImportState = ImportState.Fail,
ImportResult = "导入失败",
FailureReason = import.FailureReason
});
}
}
/// <summary>
///
/// </summary>
/// <param name="logonInfo"></param>
static public void OnLogout(TokenLogonInfo logonInfo)
{
// 处理登录用户信息
}
/// <summary>
/// 导入数据的具体操作
/// </summary>
/// <param name="import"></param>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
protected override void Import(EmployeesImportDetail import, EmployeeInfo info, TokenLogonInfo logonInfo)
{
EmployeeService employeeService = ServiceLoader.GetService <EmployeeService>();
// 新增导入的数据
employeeService.Create(info, logonInfo);
}