/// <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>
private static IEnumerable <DBMappingAttribute> LoadMapping()
{
foreach (var assembly in AssemblyHelper.GetAssemblyList())
{
foreach (Type type in assembly.GetTypes())
{
// 忽略接口
if (type.IsInterface)
{
continue;
}
// 忽略带泛型的定义 泛型定级均为基类
if (type.Name.Contains("`"))
{
continue;
}
// 类型必须继承 IDBOperation 接口
if (type.GetInterfaces().Where(i => i.ToString().Contains("IDBOperation")).Count() == 0)
{
continue;
}
// 获取数据持久化操作的特性
DBMappingAttribute attribute = type.GetCustomAttribute <DBMappingAttribute>(false);
// 数据操作必须有特性，严格检查避免代码书写错误
if (attribute == null)
{
ApiException.ThrowBadRequest($"数据持久化操作对象：{type.FullName} 必须设置数据映射特性：DBMapping");
}
// 完善特性信息
attribute.DALTypeName = type.FullName;
string baseName = type.BaseType.FullName;
int start1 = baseName.IndexOf("`1[[") + 4;
string ModelTypeName = baseName.Substring(start1, baseName.IndexOf(",") - start1);
int start2 = baseName.IndexOf(",") + 1;
string ModelAssemblyName = baseName.Substring(start2, baseName.IndexOf(",", start2) - start2);
attribute.ModelType = AssemblyHelper.GetTypeByName(ModelAssemblyName, ModelTypeName);
attribute.DBType = DBType.MongoDB;
if (string.IsNullOrWhiteSpace(attribute.ConnectionName))
{
attribute.ConnectionOptions = Connection.Default;
attribute.ConnectionName = Connection.Default.Name.ToLower();
}
else
{
attribute.ConnectionName = attribute.ConnectionName.ToLower();
attribute.ConnectionOptions = Connection.ByName(attribute.ConnectionName);
}
// 返回特性信息
yield return(attribute);
}
}
}
public void UpdateAdmin()
{
var employeeService = ServiceLoader.GetService <EmployeeService>();
if (employeeService.SearchQueryable().Count() > 0)
{
ApiException.ThrowBadRequest("系统中拥有用户信息，无密码初始化失败。您可以通过管理员账号登陆后再初始化");
}
Init();
}
/// <summary>
/// 根据ID 物理删除数据
/// </summary>
/// <param name="id">删除的ID</param>
/// <returns>返回已删除的对象信息</returns>
public T RemoveById(string id)
{
if (!ObjectId.TryParse(id, out ObjectId objId))
{
MongoLog.Logger.Error($"按ID物理删除时参数错误，无法转换成ObjectId的Id值为：[{id}]\r\n类型为：[{typeof(T).FullName}]");
ApiException.ThrowBadRequest("物理删除的ID值错误");
}
return(RemoveByTypeId(objId));
}
/// <summary>
/// 根据连接的名称获取连接信息
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public DBConnectionOptions ByName(string name)
{
var conn = ConnectionList.Where(e => e.Name == name).FirstOrDefault();
if (conn == null)
{
ApiException.ThrowBadRequest($"请完善名称为{name}的数据库连接配置");
}
return(conn);
}
/// <summary>
/// 根据批次获取导入的主表信息
/// </summary>
/// <param name="batch"></param>
/// <returns></returns>
public DataImportIndexInfo SearchMainByBatch(string batch)
{
var main = mainDal.Queryable().Where(e => e.Batch == batch).FirstOrDefault();
if (main == null)
{
ApiException.ThrowBadRequest("无法找到导入的数据信息");
}
return(main);
}
public List <SelectView> MySub()
{
if (string.IsNullOrWhiteSpace(LogonInfo.DepartmentId))
{
ApiException.ThrowBadRequest("您需要先有所属部门才可执行此操作");
}
DepartmentQuery query = new DepartmentQuery()
{
ParentId = LogonInfo.DepartmentId
};
List <SelectView> subList = _Service.Select(query);
return(subList);
}
/// <summary>
/// 保存一个主菜单信息 （子菜单不变）
/// </summary>
/// <param name="mainInfo"></param>
public void SaveMainMenu(MenuMainInfo mainInfo)
{
if (string.IsNullOrEmpty(mainInfo.Name))
{
ApiException.ThrowBadRequest("菜单名称不能为空");
}
var main = GetMainByName(mainInfo.Name);
if (main != null)
{
main.Index = main.Index;
main.Link = main.Link;
_Dal.UpdateObject(main);
}
else
{
_Dal.InsertObject(main);
}
}
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("信息修改成功"));
}
/// <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;
}
}
/// <summary>
/// 初始化数据库的连接
/// </summary>
public static void SetConnection()
{
// 创建数据库连接信息
if (Connection == null)
{
Connection = new DBConnection(DBType.MongoDB, OnChange);
}
if (Connection.ConnectionList.Count == 0)
{
ApiException.ThrowBadRequest("请填写数据库的连接配置");
}
// 为每个数据库连接创建数据库服务
Dictionary <string, MongoProvider> ConnDict = new Dictionary <string, MongoProvider>();
foreach (var conn in Connection.ConnectionList)
{
conn.Name = conn.Name.ToLower();
LoggerConnect = conn;
if (string.IsNullOrWhiteSpace(conn.Name))
{
ApiException.ThrowBadRequest("请为连接数据库的字符串指定名称");
}
if (ConnDict.ContainsKey(conn.Name))
{
continue;
}
try
{
// 获取数据链接客户端
IMongoClient MongoClient = new MongoClient(conn.ConnectionString());
// 获取数据库
IMongoDatabase MongoDatabase = MongoClient.GetDatabase(conn.Database);
ConnDict.Add(conn.Name, new MongoProvider {
Client = MongoClient, Database = MongoDatabase, Connection = conn
});
}
catch (Exception ex)
{
// 由于数据库连接字符串容易被外界改变，所以只针对连接字符串出错时记录日志并发送邮件。其它错误应该在测试阶段发现。
DBLog.Logger.Error(ex, "连接MongoDB数据库失败", Connection.ConnectionList);
throw new Exception("连接数据库失败，请检查数据库连接字符串");
}
}
// 根据持久化操作对象的特性创建数据库操作服务
ProviderDict.Clear();
foreach (var map in LoadMapping())
{
if (ProviderDict.ContainsKey(map.DALTypeName))
{
continue;
}
if (!ConnDict.ContainsKey(map.ConnectionName))
{
ApiException.ThrowBadRequest($"Mongo数据库{map.ConnectionName}连接信息不存在，请检查配置项");
}
var db = ConnDict[map.ConnectionName];
ProviderDict.Add(map.DALTypeName, new MongoProvider
{
Name = map.DALTypeName,
Client = db.Client,
Database = db.Database,
Connection = db.Connection,
CollectionName = map.CollectionName,
Collection = db.Database.GetType().GetMethod("GetCollection").MakeGenericMethod(map.ModelType).Invoke(db.Database, new object[] { map.CollectionName, null })
});
}
}
