public ResultView Login(string id)
{
DepartmentService departmentService = ServiceLoader.GetService <DepartmentService>();
var dep = departmentService._SearchById(id);
return(ResultView.Success());
//return new LoginResult { Token = token };
}
/// <summary>
/// 解锁某些用户的登录状态 - 用户连续多次由于密码错误而登录失败时，将会为用户设置登录锁状态，本功能用于解除这种登录锁的状态
/// </summary>
/// <param name="id"></param>
/// <returns></returns>
public ResultView SetUnlock(string id)
{
var emp = _SearchById(id);
emp.State = UserState.Enable;
emp.ProcessState = ProcessState.Enable;
_Dal.UpdateObject(emp);
return(ResultView.Success(id));
}
/// <summary>
///
/// </summary>
/// <param name="phoneNumber"></param>
/// <param name="msg"></param>
/// <returns></returns>
public ResultView Send(SingleSendData data)
{
SmsSingleSenderResult result = Send(0, "86", data.PhoneNumber, data.Message, "", "");
if (result.result == 0)
{
return(ResultView.Success());
}
throw ApiException.BadRequest(result.errMsg);
}
public ResultView SetHeadImg(string employeeId, Microsoft.AspNetCore.Http.IFormFile imageFile)
{
string webFile = $"~/wwwroot/UploadFiles/Employee/Head/{employeeId}/{Guid.NewGuid().ToString()}";
UploadFileInfo file = UploadFileHandle.UploadImage(webFile, imageFile);
var info = _Service._SearchById(employeeId);
UploadFileHandle.Delete(info.HeadImg);
info.HeadImg = file.WebFileName;
_Service.Update(info, LogonInfo);
return(ResultView.Success("头像修改成功"));
}
/// <summary>
/// 修改用户密码
/// </summary>
/// <param name="id"></param>
/// <param name="oldPwd"></param>
/// <param name="newPwd"></param>
/// <returns></returns>
public ResultView UpdatePassword(string id, string oldPwd, string newPwd)
{
if (string.IsNullOrWhiteSpace(newPwd.Trim()))
{
throw ApiException.BadRequest("请输入新密码");
}
var emp = _Dal.SearchById(id);
if (!emp.LogonPassword.Equals(oldPwd))
{
throw ApiException.BadRequest("原密码输入错误");
}
emp.LogonPassword = newPwd;
_Dal.UpdateObject(emp);
return(ResultView.Success(emp.Id));
}
public ResultView SendEmail()
{
if (_Logger == null)
{
_Logger = new Serilog.LoggerConfiguration()
.WriteTo.Email(
fromEmail: "*****@*****.**",
toEmail: "*****@*****.**",
mailServer: "smtp.163.com",
restrictedToMinimumLevel: Serilog.Events.LogEventLevel.Warning,
networkCredential: new System.Net.NetworkCredential("*****@*****.**", "1234qwer"),
outputTemplate: "[{Level}] {Message}{NewLine}{Exception}",
mailSubject: "系统错误-提醒邮件")
.CreateLogger();
}
_Logger.Fatal("测试邮件 {test}", "邮件发送内容");
return(ResultView.Success());
}
/// <summary>
/// 逻辑删除
/// </summary>
/// <param name="info">要删除的数据id</param>
/// <param name="logonInfo">登录的用户信息</param>
/// <returns></returns>
public ResultView Delete(T info, TokenLogonInfo logonInfo)
{
if (info == null)
{
throw ApiException.EmptyData("无法找到要删除的数据");
}
string id = info.Id.ToString();
_logger.LogTrace($"逻辑删除 ==> 类型为：[{typeof(T).FullName}]\t删除ID为：[{id}]");
try
{
// 判断对应数据是否可以删除.
DeleteRemoveCheck(info);
OnDeleteRemoveCheck?.Invoke(info, logonInfo);
DeleteCheck(info);
OnDeleteCheck?.Invoke(info, logonInfo);
// 逻辑删除的前置操作
DeleteRemoving(info, logonInfo);
Deleting(info, logonInfo);
// 逻辑删除前置事件处理
OnDeleting?.Invoke(info, logonInfo);
// 设置逻辑删除状态
info.UpdateDate = DateTime.Now;
info.UpdaterId = logonInfo.Id;
info.UpdaterName = logonInfo.Name;
info.IsDelete = true;
// 持久化数据
_Dal.UpdateObject(info);
// 逻辑删除的后置处理
Deleted(info, logonInfo);
DeleteRemoved(info, logonInfo);
// 逻辑删除后置事件处理
OnDeleted?.Invoke(info, logonInfo);
// 返回保存结果
return(ResultView.Success(id));
}
catch (Exception ex)
{
_logger.LogError(ex, $"逻辑删除异常 ==> 类型为：[{typeof(T).FullName}]\t删除ID为：[{id}]\r\n删除对象：[{info.ToJson()}]");
throw;
}
}
/// <summary>
/// 取消逻辑删除
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
/// <returns></returns>
public virtual ResultView UnDelete(T info, TokenLogonInfo logonInfo)
{
// 判断id是否有对应数据
if (info == null)
{
throw ApiException.EmptyData("无法找到要还原的数据");
}
string id = info.Id.ToString();
_logger.LogTrace($"还原删除数据 ==> 类型为：[{typeof(T).FullName}]\t还原ID为：[{id}]");
try
{
// 取消逻辑删除的前置操作
UnDeleting(info, logonInfo);
// 取消逻辑删除的前置事件处理
OnUnDeleting?.Invoke(info, logonInfo);
// 取消删除状态
info.UpdateDate = DateTime.Now;
info.UpdaterId = logonInfo.Id;
info.UpdaterName = logonInfo.Name;
info.IsDelete = false;
// 持久化数据
_Dal.UpdateObject(info);
// 还原的后置操作
UnDeleted(info, logonInfo);
// 取消还原删除的后置事件处理
OnUnDeleted?.Invoke(info, logonInfo);
// 返回保存结果
return(ResultView.Success(id));
}
catch (Exception ex)
{
_logger.LogError(ex, $"还原删除数据异常 ==> 类型为：[{typeof(T).FullName}]\t还原ID为：[{id}]\r\n还原对象：[{info.ToJson()}]");
throw;
}
}
/// <summary>
/// 删除导入数据
/// </summary>
/// <param name="batch"></param>
/// <returns></returns>
public ResultView Remove(string batch)
{
// 获取主表数据
var main = SearchMainByBatch(batch);
// 1、删除上传文件
if (main.ImportFile != null && String.IsNullOrWhiteSpace(main.ImportFile.DiskFileFullName) && System.IO.File.Exists(main.ImportFile.DiskFileFullName))
{
System.IO.File.Delete(main.ImportFile.DiskFileFullName);
}
// 2、删除导入失败报表文件
if (main.FailImportFile != null && String.IsNullOrWhiteSpace(main.FailImportFile.DiskFileFullName) && System.IO.File.Exists(main.FailImportFile.DiskFileFullName))
{
System.IO.File.Delete(main.FailImportFile.DiskFileFullName);
}
// 3、删除明细表数据
var detailIds = detailDal.Queryable().Where(e => e.Batch == batch).Select(e => e.Id);
detailDal.RemoveByTypeIdList(detailIds);
// 4、删除主表信息
mainDal.RemoveByTypeId(main.Id);
return(ResultView.Success());
}
/// <summary>
/// 物理删除
/// </summary>
/// <param name="info"></param>
/// <param name="logonInfo"></param>
/// <returns></returns>
public ResultView Remove(T info, TokenLogonInfo logonInfo)
{
if (info == null)
{
throw ApiException.EmptyData("无法找到要删除的数据");
}
string id = info.Id.ToString();
_logger.LogTrace($"物理删除 ==> 类型为：[{typeof(T).FullName}]\t删除ID为：[{id}]");
try
{
// 判断对应数据是否可以删除.
DeleteRemoveCheck(info);
OnDeleteRemoveCheck?.Invoke(info, logonInfo);
RemoveCheck(info);
OnRemoveCheck?.Invoke(info, logonInfo);
// 物理删除的前置操作
DeleteRemoving(info, logonInfo);
Removing(info, logonInfo);
// 物理删除时的前置事件处理
OnRemoving?.Invoke(info, logonInfo);
// 持久化数据
_Dal.RemoveObject(info);
// 物理删除的后置处理
Removed(info, logonInfo);
DeleteRemoved(info, logonInfo);
// 物理删除时的后置事件处理
OnRemoved?.Invoke(info, logonInfo);
// 返回保存结果
return(ResultView.Success(info.Id.ToString()));
}
catch (Exception ex)
{
_logger.LogError(ex, $"物理删除异常 ==> 类型为：[{typeof(T).FullName}]\t删除ID为：[{id}]]\r\n删除对象为：[{info.ToJson()}]");
throw;
}
}
public ResultView SetProperty([FromBody] SetPropertyView view)
{
if (string.IsNullOrWhiteSpace(view.PropertyName))
{
ApiException.ThrowBadRequest("属性名不能为空");
}
var info = _Service._SearchById(LogonInfo.Id);
switch (view.PropertyName.ToLower())
{
case "position": { info.Position = view.PropertyValue; break; }
case "name": { info.Name = view.PropertyValue; break; }
case "nickname": { info.Nickname = view.PropertyValue; break; }
case "mobile": { info.Mobile = view.PropertyValue; break; }
case "telephone": { info.Telephone = view.PropertyValue; break; }
}
_Service.Update(info, LogonInfo);
return(ResultView.Success("信息修改成功"));
}
public ResultView Logout()
{
_authService.Logout(LogonInfo);
return(ResultView.Success());
}
public ResultView UpdateAllPassword()
{
_Service.UpdateAllPassword("123456");
return(ResultView.Success());
}
public ResultView RootPath()
{
return(ResultView.Success(ServiceLoader.Environment.ContentRootPath));
}
/// <summary>
/// 更新一个对象信息
/// </summary>
/// <param name="info">更新对象</param>
/// <param name="logonInfo">登录人信息</param>
/// <returns></returns>
public virtual ResultView Update(T info, TokenLogonInfo logonInfo)
{
if (info == null)
{
ApiException.ThrowBadRequest("更新对象不能为空");
}
_logger.LogTrace($"更新一个对象信息 ==> 类型为：[{typeof(T).FullName}]\r\n操作人信息：[{logonInfo.ToJson()}]\r\n更新对象：[{info.ToJson()}]");
try
{
// 根据ID获取原数据信息
var old = _SearchById(info.Id);
// 更新数据前的预制数据
info.CreateDate = old.CreateDate;
info.CreaterId = old.CreaterId;
info.CreaterName = old.CreaterName;
info.UpdateDate = DateTime.Now;
info.UpdaterId = logonInfo.Id;
info.UpdaterName = logonInfo.Name;
info.IsDelete = false;
if (info.ProcessState == ProcessState.None)
{
info.ProcessState = ProcessState.Edit;
}
#region 保存验证
// 保存的数据校验，可以被重写
SavingCheck(info, logonInfo);
// 判断是否可以执行新增操作，可以被重写
if (!IsExecuteUpdate(info, old, logonInfo))
{
return(ResultView.Success());
}
OnUpdateCheck?.Invoke(info, old, logonInfo);
OnSaveCheck?.Invoke(info, logonInfo);
#endregion
#region 保存的前置处理
// 更新的前置操作，可以被重写
Updating(info, old, logonInfo);
// 新增/保存的通用前置操作，可以被重写
Saving(info, logonInfo);
// 事件处理
OnUpdating?.Invoke(info, old, logonInfo);
OnSaving?.Invoke(info, logonInfo);
#endregion
// 持久化数据
_Dal.UpdateObject(info);
#region 保存后置处理
// 更新的后置操作，可以被重写
Updated(info, old, logonInfo);
// 新增/保存的通用后置操作，可以被重写
Saved(info, logonInfo);
// 新增后的后置事件处理
OnUpdated?.Invoke(info, old, logonInfo);
OnSaved?.Invoke(info, logonInfo);
#endregion
// 返回保存结果
return(ResultView.Success(info.IdString));
}
catch (Exception ex)
{
_logger.LogError(ex, $"更新一个对象信息异常 ==> 类型为：[{typeof(T).FullName}]\r\n操作人信息：[{logonInfo.ToJson()}]\r\n更新对象：[{info.ToJson()}]");
throw;
}
}
/// <summary>
/// 创建一个对象信息
/// </summary>
/// <param name="info">新增对象</param>
/// <param name="logonInfo">登录人信息</param>
/// <returns></returns>
public virtual ResultView Create(T info, TokenLogonInfo logonInfo)
{
if (info == null)
{
ApiException.ThrowBadRequest("新增对象不能为空");
}
_logger.LogTrace($"新增一个对象信息 ==> 类型为：[{typeof(T).FullName}]\r\n新增对象：[{info.ToJson()}]");
try
{
// 新增数据前的预制数据
info.CreateDate = DateTime.Now;
info.UpdateDate = DateTime.Now;
info.UpdaterId = logonInfo.Id;
info.UpdaterName = logonInfo.Name;
info.CreaterId = logonInfo.Id;
info.CreaterName = logonInfo.Name;
info.IsDelete = false;
info.ProcessState = ProcessState.Edit;
#region 保存验证
// 保存的数据校验
SavingCheck(info, logonInfo);
// 判断是否可以执行新增操作
if (!IsExecuteCreate(info, logonInfo))
{
return(ResultView.Success());
}
// 保存数据验证的事件处理
OnCreateCheck?.Invoke(info, logonInfo);
OnSaveCheck?.Invoke(info, logonInfo);
#endregion
#region 保存的前置处理
// 新增的前置操作，可以被重写
Creating(info, logonInfo);
// 新增/保存的通用前置操作，可以被重写
Saving(info, logonInfo);
// 新增时的前置事件处理
OnCreating?.Invoke(info, logonInfo);
OnSaving?.Invoke(info, logonInfo);
#endregion
// 持久化数据
_Dal.InsertObject(info);
#region 保存后置处理
// 新增的通用后置操作，可以被重写
Created(info, logonInfo);
// 新增/保存的通用后置操作，可以被重写
Saved(info, logonInfo);
// 新增后的后置事件处理
OnCreated?.Invoke(info, logonInfo);
OnSaved?.Invoke(info, logonInfo);
#endregion
// 返回保存结果
return(ResultView.Success(info.IdString));
}
catch (Exception ex)
{
_logger.LogError(ex, $"新增一个对象信息异常 ==> 类型为：[{typeof(T).FullName}]\r\n操作人信息：[{logonInfo.ToJson()}]\r\n新增对象：[{info.ToJson()}]");
throw;
}
}
public ResultView UpdatePasswordMe([FromBody] UpdatePasswordMeView view)
{
_Service.UpdatePassword(LogonInfo.Id, view.OldPwd, view.NewPwd);
return(ResultView.Success("密码修改成功"));
}
public ResultView UpdateToV2()
{
Service.UpdateToV2();
return(ResultView.Success());
}
public ResultView Init()
{
_Service.Init();
return(ResultView.Success());
}
