/// <summary>
/// Remove datas
/// </summary>
/// <param name="datas">Datas</param>
/// <param name="activationOption">Activation option</param>
public sealed override void Remove(IEnumerable <TModel> datas, ActivationOption activationOption = null)
{
if (datas.IsNullOrEmpty())
{
throw new EZNEWException($"{nameof(datas)} is null or empty");
}
var records = new List <IActivationRecord>();
foreach (var data in datas)
{
if (data == null)
{
throw new EZNEWException("remove object data is null");
}
if (!data.CanBeRemove)
{
throw new EZNEWException($"Data:{data.IdentityValue} cann't to be remove");
}
var record = ExecuteRemove(data, activationOption);//Execute remove
if (record != null)
{
records.Add(record);
}
}
RepositoryEventBus.PublishRemove(GetType(), datas, activationOption);
WorkManager.RegisterActivationRecord(records);
}
/// <summary>
/// save async
/// </summary>
/// <param name="datas">datas</param>
public sealed override async Task SaveAsync(IEnumerable<Tuple<First, Second, Third>> datas)
{
var records = await ExecuteSaveAsync(datas).ConfigureAwait(false);
if (records.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishSave<Tuple<First, Second, Third>>(GetType(), datas);
WorkFactory.RegisterActivationRecord(records.ToArray());
}
/// <summary>
/// save by third datas
/// </summary>
/// <param name="datas">datas</param>
public sealed override void SaveByThird(IEnumerable<Third> datas)
{
var saveRecords = ExecuteSaveByThirdAsync(datas).Result;
if (saveRecords.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishSave<Third>(GetType(), datas);
WorkFactory.RegisterActivationRecord(saveRecords.ToArray());
}
/// <summary>
/// Save by second type datas
/// </summary>
/// <param name="datas">Datas</param>
/// <param name="activationOption">Activation option</param>
public sealed override void SaveBySecond(IEnumerable <TSecondModel> datas, ActivationOption activationOption = null)
{
var saveRecords = ExecuteSaveBySecond(datas, activationOption);
if (saveRecords.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishSave(GetType(), datas, activationOption);
WorkManager.RegisterActivationRecord(saveRecords);
}
public static void Init()
{
#region User
//删除用户->删除用户&角色绑定
RepositoryEventBus.SubscribeRemove <IUserRepository, IUserRoleRepository, User>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//删除用户->删除用户授权
RepositoryEventBus.SubscribeRemove <IUserRepository, IUserAuthorizeRepository, User>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//查询用户->用户转换
RepositoryEventBus.SubscribeQuery <IUserRepository, IAdminUserRepository, User>(c => c.LoadAdminUser);
#endregion
#region Role
//删除角色->删除角色&用户绑定
RepositoryEventBus.SubscribeRemove <IRoleRepository, IUserRoleRepository, Role>(c => c.RemoveBySecond, c => c.RemoveBySecond);
//删除角色->删除角色授权
RepositoryEventBus.SubscribeRemove <IRoleRepository, IRoleAuthorizeRepository, Role>(c => c.RemoveByFirst, c => c.RemoveByFirst);
#endregion
#region AuthorityOperationGroup
//删除授权操作分组->删除分组下的授权操作
RepositoryEventBus.SubscribeRemove <IAuthorityOperationGroupRepository, IAuthorityOperationRepository, AuthorityOperationGroup>(c => c.RemoveOperationByGroup, c => c.RemoveOperationByGroup);
#endregion
#region AuthorityOperation
//删除授权操作->删除权限&授权操作绑定
RepositoryEventBus.SubscribeRemove <IAuthorityOperationRepository, IAuthorityBindOperationRepository, AuthorityOperation>(c => c.RemoveBySecond, c => c.RemoveBySecond);
#endregion
#region AuthorityGroup
//删除权限分组->删除分组下的权限数据
RepositoryEventBus.SubscribeRemove <IAuthorityGroupRepository, IAuthorityRepository, AuthorityGroup>(c => c.RemoveAuthorityByGroup, c => c.RemoveAuthorityByGroup);
#endregion
#region Authority
//删除权限->删除权限&授权操作绑定
RepositoryEventBus.SubscribeRemove <IAuthorityRepository, IAuthorityBindOperationRepository, Authority>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//删除权限->删除角色授权
RepositoryEventBus.SubscribeRemove <IAuthorityRepository, IRoleAuthorizeRepository, Authority>(c => c.RemoveBySecond, c => c.RemoveBySecond);
//删除权限->删除用户授权
RepositoryEventBus.SubscribeRemove <IAuthorityRepository, IUserAuthorizeRepository, Authority>(c => c.RemoveBySecond, c => c.RemoveBySecond);
#endregion
}
/// <summary>
/// remove by condition
/// </summary>
/// <param name="query">query</param>
public sealed override async Task RemoveAsync(IQuery query)
{
var record = await ExecuteRemoveAsync(query).ConfigureAwait(false);
if (record == null)
{
return;
}
RepositoryEventBus.PublishRemove <Tuple <First, Second> >(GetType(), query);
WorkFactory.RegisterActivationRecord(record);
}
/// <summary>
/// Remove
/// </summary>
/// <param name="datas">Datas</param>
/// <param name="activationOption">Activation option</param>
public sealed override void Remove(IEnumerable <Tuple <TFirstModel, TSecondModel> > datas, ActivationOption activationOption = null)
{
var records = ExecuteRemove(datas, activationOption);
if (records.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishRemove(GetType(), datas, activationOption);
WorkManager.RegisterActivationRecord(records);
}
/// <summary>
/// remove by third datas
/// </summary>
/// <param name="datas">datas</param>
/// <param name="record">activation record</param>
public sealed override void RemoveByThird(IEnumerable <Third> datas)
{
if (datas.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishRemove <Third>(GetType(), datas);
IQuery query = CreateQueryByThird(datas);
Remove(query);
}
/// <summary>
/// Modify Object
/// </summary>
/// <param name="expression">modify expression</param>
/// <param name="query">query model</param>
public sealed override async Task ModifyAsync(IModify expression, IQuery query)
{
var record = await ExecuteModifyAsync(expression, query).ConfigureAwait(false);
if (record == null)
{
return;
}
RepositoryEventBus.PublishModify <DT>(GetType(), expression, query);
WorkFactory.RegisterActivationRecord(record);
}
/// <summary>
/// save by second type datas
/// </summary>
/// <param name="datas">datas</param>
/// <param name="activationOption">activation option</param>
public sealed override void SaveBySecond(IEnumerable <Second> datas, ActivationOption activationOption = null)
{
var saveRecords = ExecuteSaveBySecondAsync(datas, activationOption).Result;
if (saveRecords.IsNullOrEmpty())
{
return;
}
RepositoryEventBus.PublishSave(GetType(), datas, activationOption);
WorkFactory.RegisterActivationRecord(saveRecords.ToArray());
}
/// <summary>
/// remove by second datas
/// </summary>
/// <param name="datas">datas</param>
public sealed override void RemoveBySecond(IEnumerable <Second> datas)
{
var removeRecord = ExecuteRemoveBySecond(datas);
if (removeRecord == null)
{
return;
}
RepositoryEventBus.PublishRemove(GetType(), datas);
WorkFactory.RegisterActivationRecord(removeRecord);
}
/// <summary>
/// Modify data
/// </summary>
/// <param name="expression">Modify expression</param>
/// <param name="query">Query object</param>
/// <param name="activationOption">Activation option</param>
public sealed override void Modify(IModify expression, IQuery query, ActivationOption activationOption = null)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Modify, AppendModifyCondition);
var record = ExecuteModify(expression, newQuery, activationOption);
if (record != null)
{
RepositoryEventBus.PublishModify <TModel>(GetType(), expression, newQuery, activationOption);
WorkManager.RegisterActivationRecord(record);
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Modify);
}
}
/// <summary>
/// Remove by condition
/// </summary>
/// <param name="query">Query object</param>
/// <param name="activationOption">Activation option</param>
public sealed override void Remove(IQuery query, ActivationOption activationOption = null)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Remove, AppendRemoveCondition);
var record = ExecuteRemove(newQuery, activationOption);
if (record != null)
{
RepositoryEventBus.PublishRemove <TModel>(GetType(), newQuery, activationOption);
WorkManager.RegisterActivationRecord(record);
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Remove);
}
}
public static void Configure()
{
#region User
//删除用户->删除用户&角色绑定
RepositoryEventBus.SubscribeRemove <IUserRepository, IUserRoleRepository, User>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//删除用户->删除用户授权
RepositoryEventBus.SubscribeRemove <IUserRepository, IUserPermissionRepository, User>(c => c.RemoveByFirst, c => c.RemoveByFirst);
#endregion
#region Role
//删除角色->删除角色&用户绑定
RepositoryEventBus.SubscribeRemove <IRoleRepository, IUserRoleRepository, Role>(c => c.RemoveBySecond, c => c.RemoveBySecond);
//删除角色->删除角色授权
RepositoryEventBus.SubscribeRemove <IRoleRepository, IRolePermissionRepository, Role>(c => c.RemoveByFirst, c => c.RemoveByFirst);
#endregion
#region AuthorityOperationGroup
//删除授权操作分组->删除分组下的授权操作
RepositoryEventBus.SubscribeRemove <IOperationGroupRepository, IOperationRepository, OperationGroup>(c => c.RemoveOperationByGroup, c => c.RemoveOperationByGroup);
#endregion
#region AuthorityOperation
//删除授权操作->删除权限&授权操作绑定
RepositoryEventBus.SubscribeRemove <IOperationRepository, IPermissionOperationRepository, Operation>(c => c.RemoveBySecond, c => c.RemoveBySecond);
#endregion
#region AuthorityGroup
//删除权限分组->删除分组下的权限数据
RepositoryEventBus.SubscribeRemove <IPermissionGroupRepository, IPermissionRepository, PermissionGroup>(c => c.RemovePermissionByGroup, c => c.RemovePermissionByGroup);
#endregion
#region Authority
//删除权限->删除权限&授权操作绑定
RepositoryEventBus.SubscribeRemove <IPermissionRepository, IPermissionOperationRepository, Permission>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//删除权限->删除角色授权
RepositoryEventBus.SubscribeRemove <IPermissionRepository, IRolePermissionRepository, Permission>(c => c.RemoveBySecond, c => c.RemoveBySecond);
//删除权限->删除用户授权
RepositoryEventBus.SubscribeRemove <IPermissionRepository, IUserPermissionRepository, Permission>(c => c.RemoveBySecond, c => c.RemoveBySecond);
#endregion
}
/// <summary>
/// remove by condition
/// </summary>
/// <param name="query">query</param>
/// <param name="activationOption">activation option</param>
public sealed override async Task RemoveAsync(IQuery query, ActivationOption activationOption = null)
{
//append condition
query = AppendRemoveCondition(query);
var record = await ExecuteRemoveAsync(query, activationOption).ConfigureAwait(false);
if (record == null)
{
return;
}
RepositoryEventBus.PublishRemove <Tuple <First, Second, Third> >(GetType(), query, activationOption);
WorkFactory.RegisterActivationRecord(record);
}
/// <summary>
/// Remove by condition
/// </summary>
/// <param name="query">Query object</param>
/// <param name="activationOptions">Activation options</param>
public sealed override void Remove(IQuery query, ActivationOptions activationOptions = null)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Remove, AppendRemoveCondition);
var record = ExecuteRemove(newQuery, activationOptions);
if (record == null)
{
return;
}
RepositoryEventBus.PublishRemove <Tuple <TFirstModel, TSecondModel, TThirdModel> >(GetType(), newQuery, activationOptions);
WorkManager.RegisterActivationRecord(record);
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Remove);
}
/// <summary>
/// modify data
/// </summary>
/// <param name="expression">modify expression</param>
/// <param name="query">query object</param>
/// <param name="activationOption">activation option</param>
public sealed override async Task ModifyAsync(IModify expression, IQuery query, ActivationOption activationOption = null)
{
//append condition
query = AppendModifyCondition(query);
var record = await ExecuteModifyAsync(expression, query, activationOption).ConfigureAwait(false);
if (record == null)
{
return;
}
RepositoryEventBus.PublishModify <T>(GetType(), expression, query, activationOption);
WorkFactory.RegisterActivationRecord(record);
}
/// <summary>
/// Remove Object
/// </summary>
/// <param name="query">query model</param>
public sealed override async Task RemoveAsync(IQuery query)
{
//query filter
query = GlobalQueryFilter(query);
query = RemoveQueryFilter(query);
var record = await ExecuteRemoveAsync(query).ConfigureAwait(false);
if (record == null)
{
return;
}
RepositoryEventBus.PublishRemove <DT>(GetType(), query);
WorkFactory.RegisterActivationRecord(record);
}
/// <summary>
/// Get Object List
/// </summary>
/// <param name="query">query model</param>
/// <returns>object list</returns>
public sealed override async Task <List <DT> > GetListAsync(IQuery query)
{
var datas = await GetDataListAsync(query).ConfigureAwait(false);
QueryCallback(query, true, datas);
RepositoryEventBus.PublishQuery <DT>(GetType(), datas, result =>
{
QueryEventResult <DT> queryResult = result as QueryEventResult <DT>;
if (queryResult != null)
{
datas = queryResult.Datas;
}
});
return(datas ?? new List <DT>(0));
}
/// <summary>
/// Get Object Paging
/// </summary>
/// <param name="query">query model</param>
/// <returns>object paging</returns>
public sealed override async Task <IPaging <DT> > GetPagingAsync(IQuery query)
{
var paging = await GetDataPagingAsync(query).ConfigureAwait(false);
IEnumerable <DT> datas = paging;
QueryCallback(query, true, datas);
RepositoryEventBus.PublishQuery <DT>(GetType(), datas, result =>
{
QueryEventResult <DT> queryResult = result as QueryEventResult <DT>;
if (queryResult != null)
{
datas = queryResult.Datas;
}
});
return(new Paging <DT>(paging.Page, paging.PageSize, paging.TotalCount, datas));
}
/// <summary>
/// Get data list
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return data list</returns>
public sealed override async Task <List <TModel> > GetListAsync(IQuery query)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Query, AppendQueryCondition);
var datas = await GetDataListAsync(newQuery).ConfigureAwait(false);
QueryCallback(newQuery, true, datas);
RepositoryEventBus.PublishQuery(GetType(), datas, newQuery, result =>
{
QueryEventResult <TModel> queryResult = result as QueryEventResult <TModel>;
if (queryResult != null)
{
datas = queryResult.Datas;
}
});
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Query);
return(datas ?? new List <TModel>(0));
}
/// <summary>
/// save datas
/// </summary>
/// <param name="datas">Datas</param>
/// <param name="activationOptions">Activation options</param>
public sealed override List <TModel> Save(IEnumerable <TModel> datas, ActivationOptions activationOptions = null)
{
if (datas.IsNullOrEmpty())
{
throw new EZNEWException($"{nameof(datas)} is null or empty");
}
var records = new List <IActivationRecord>();
var resultDatas = new List <TModel>();
foreach (var data in datas)
{
if (data == null)
{
continue;
}
var saveData = data;
if (!saveData.IdentityValueIsNone() && saveData.IsNew)
{
var nowData = Get(saveData);
if (nowData != null)
{
saveData = nowData.OnUpdating(saveData);
}
}
if (saveData.IsNew)
{
saveData = saveData.OnAdding();
}
if (!saveData.CanBeSave)
{
throw new EZNEWException($"Data:{saveData.IdentityValue} cann't to be save");
}
var record = ExecuteSave(saveData, activationOptions);
if (record != null)
{
records.Add(record);
resultDatas.Add(saveData);
}
}
RepositoryEventBus.PublishSave(GetType(), datas, activationOptions);
WorkManager.RegisterActivationRecord(records);
return(resultDatas);
}
/// <summary>
/// Get data paging
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return data paging</returns>
public sealed override async Task <IPaging <TModel> > GetPagingAsync(IQuery query)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Query, AppendQueryCondition);
var paging = await GetDataPagingAsync(newQuery).ConfigureAwait(false);
IEnumerable <TModel> datas = paging;
QueryCallback(newQuery, true, datas);
RepositoryEventBus.PublishQuery(GetType(), datas, newQuery, result =>
{
QueryEventResult <TModel> queryResult = result as QueryEventResult <TModel>;
if (queryResult != null)
{
datas = queryResult.Datas;
}
});
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Query);
return(Pager.Create(paging.Page, paging.PageSize, paging.TotalCount, datas));
}
/// <summary>
/// Get Object
/// </summary>
/// <param name="query">query model</param>
/// <returns>Object</returns>
public sealed override async Task <DT> GetAsync(IQuery query)
{
var data = await GetDataAsync(query).ConfigureAwait(false);
var dataList = new List <DT>()
{
data
};
QueryCallback(query, false, dataList);
RepositoryEventBus.PublishQuery <DT>(GetType(), dataList, result =>
{
QueryEventResult <DT> queryResult = result as QueryEventResult <DT>;
if (queryResult != null)
{
dataList = queryResult.Datas;
}
});
return(dataList.IsNullOrEmpty() ? default(DT) : dataList.FirstOrDefault());
}
/// <summary>
/// Get data
/// </summary>
/// <param name="query">Query object</param>
/// <returns>Return data</returns>
public sealed override async Task <TModel> GetAsync(IQuery query)
{
var newQuery = RepositoryManager.HandleQueryObjectBeforeExecute(query, QueryUsageScene.Query, AppendQueryCondition);
var data = await GetDataAsync(newQuery).ConfigureAwait(false);
var dataList = new List <TModel>(1)
{
data
};
QueryCallback(newQuery, false, dataList);
RepositoryEventBus.PublishQuery(GetType(), dataList, newQuery, result =>
{
QueryEventResult <TModel> queryResult = result as QueryEventResult <TModel>;
if (queryResult != null)
{
dataList = queryResult.Datas;
}
});
RepositoryManager.HandleQueryObjectAfterExecute(query, newQuery, QueryUsageScene.Query);
return(dataList.IsNullOrEmpty() ? default : dataList.FirstOrDefault());
}
/// <summary>
/// save datas
/// </summary>
/// <param name="datas">datas</param>
/// <param name="activationOption">activation option</param>
public sealed override async Task SaveAsync(IEnumerable <T> datas, ActivationOption activationOption = null)
{
#region verify parameters
if (datas.IsNullOrEmpty())
{
throw new Exception($"{nameof(datas)} is null or empty");
}
foreach (var obj in datas)
{
if (obj == null)
{
continue;
}
if (!obj.CanBeSave)
{
throw new Exception("data cann't to be save");
}
}
#endregion
var records = new List <IActivationRecord>(datas.Count());
foreach (var data in datas)
{
var record = await ExecuteSaveAsync(data, activationOption).ConfigureAwait(false);//execute save
if (record == null)
{
continue;
}
records.Add(record);
}
RepositoryEventBus.PublishSave(GetType(), datas, activationOption);
WorkFactory.RegisterActivationRecord(records.ToArray());
}
/// <summary>
/// Remove Objects
/// </summary>
/// <param name="objDatas">objects</param>
public sealed override async Task RemoveAsync(params DT[] objDatas)
{
#region Verify Parameters
if (objDatas == null || objDatas.Length <= 0)
{
throw new Exception("objDatas is null or empty");
}
foreach (var obj in objDatas)
{
if (obj == null)
{
throw new Exception("remove object data is null");
}
if (!obj.CanBeRemove)
{
throw new Exception("object data cann't to be remove");
}
}
#endregion
var records = new List <IActivationRecord>(objDatas.Length);
foreach (var data in objDatas)
{
var record = await ExecuteRemoveAsync(data).ConfigureAwait(false);//execute remove
if (record == null)
{
continue;
}
records.Add(record);
}
RepositoryEventBus.PublishRemove(GetType(), objDatas);
WorkFactory.RegisterActivationRecord(records.ToArray());
}
public static void Init()
{
#region Sys
#region User
//删除用户->删除用户&角色绑定
RepositoryEventBus.SubscribeRemove <IUserRepository, IUserRoleRepository, User>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//删除用户->删除用户授权
RepositoryEventBus.SubscribeRemove <IUserRepository, IUserAuthorizeRepository, User>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//查询用户->用户转换
RepositoryEventBus.SubscribeQuery <IUserRepository, IAdminUserRepository, User>(c => c.LoadAdminUser);
#endregion
#region Role
//删除角色->删除角色&用户绑定
RepositoryEventBus.SubscribeRemove <IRoleRepository, IUserRoleRepository, Role>(c => c.RemoveBySecond, c => c.RemoveBySecond);
//删除角色->删除角色授权
RepositoryEventBus.SubscribeRemove <IRoleRepository, IRoleAuthorizeRepository, Role>(c => c.RemoveByFirst, c => c.RemoveByFirst);
#endregion
#region AuthorityOperationGroup
//删除授权操作分组->删除分组下的授权操作
RepositoryEventBus.SubscribeRemove <IAuthorityOperationGroupRepository, IAuthorityOperationRepository, AuthorityOperationGroup>(c => c.RemoveOperationByGroup, c => c.RemoveOperationByGroup);
#endregion
#region AuthorityOperation
//删除授权操作->删除权限&授权操作绑定
RepositoryEventBus.SubscribeRemove <IAuthorityOperationRepository, IAuthorityBindOperationRepository, AuthorityOperation>(c => c.RemoveBySecond, c => c.RemoveBySecond);
#endregion
#region AuthorityGroup
//删除权限分组->删除分组下的权限数据
RepositoryEventBus.SubscribeRemove <IAuthorityGroupRepository, IAuthorityRepository, AuthorityGroup>(c => c.RemoveAuthorityByGroup, c => c.RemoveAuthorityByGroup);
#endregion
#region Authority
//删除权限->删除权限&授权操作绑定
RepositoryEventBus.SubscribeRemove <IAuthorityRepository, IAuthorityBindOperationRepository, Authority>(c => c.RemoveByFirst, c => c.RemoveByFirst);
//删除权限->删除角色授权
RepositoryEventBus.SubscribeRemove <IAuthorityRepository, IRoleAuthorizeRepository, Authority>(c => c.RemoveBySecond, c => c.RemoveBySecond);
//删除权限->删除用户授权
RepositoryEventBus.SubscribeRemove <IAuthorityRepository, IUserAuthorizeRepository, Authority>(c => c.RemoveBySecond, c => c.RemoveBySecond);
#endregion
#endregion
#region CTask
#region server node
//删除服务节点->删除服务节点&任务承载关系
RepositoryEventBus.SubscribeObjectRemove <IServerNodeRepository, IJobServerHostRepository, ServerNode>(r => r.RemoveJobServerHostByServer);
//删除服务节点->删除服务节点&执行计划承载关系
RepositoryEventBus.SubscribeObjectRemove <IServerNodeRepository, ITriggerServerRepository, ServerNode>(r => r.RemoveTriggerServerByServer);
#endregion
#region job group
//删除工作分组->删除工作分组下的工作
RepositoryEventBus.SubscribeRemove <IJobGroupRepository, IJobRepository, JobGroup>(r => r.RemoveByJobGroup, r => r.RemoveByJobGroup);
#endregion
#region job
//删除工作->删除工作&服务节点承载
RepositoryEventBus.SubscribeObjectRemove <IJobRepository, IJobServerHostRepository, Job>(r => r.RemoveJobServerHostByJob);
//删除工作->删除工作任务计划
RepositoryEventBus.SubscribeObjectRemove <IJobRepository, ITriggerRepository, Job>(r => r.RemoveTriggerByJob);
#endregion
#region job server host
//删除任务&服务承载->删除服务&任务执行计划
RepositoryEventBus.SubscribeObjectRemove <IJobServerHostRepository, ITriggerServerRepository, JobServerHost>(r => r.RemoveTriggerServerByJobHost);
#endregion
#region trigger
//保存执行计划->根据计划类型不同分别执行保存
RepositoryEventBus.SubscribeSave <ITriggerRepository, ISimpleTriggerRepository, Trigger>(c => c.SaveSimpleTrigger); //简单执行计划
RepositoryEventBus.SubscribeSave <ITriggerRepository, IExpressionTriggerRepository, Trigger>(c => c.SaveExpressionTrigger); //自定义执行计划
//保存执行计划->保存执行计划
RepositoryEventBus.SubscribeSave <ITriggerRepository, ITriggerConditionRepository, Trigger>(c => c.SaveTriggerConditionFromTrigger); //自定义执行计划
//删除执行计划->根据计划类型删除特定信息
RepositoryEventBus.SubscribeObjectRemove <ITriggerRepository, ISimpleTriggerRepository, Trigger>(c => c.RemoveSimpleTrigger); //简单执行计划
RepositoryEventBus.SubscribeSave <ITriggerRepository, IExpressionTriggerRepository, Trigger>(c => c.RemoveExpressionTrigger); //自定义执行计划
//删除执行计划->删除附加条件
RepositoryEventBus.SubscribeSave <ITriggerRepository, ITriggerConditionRepository, Trigger>(c => c.RemoveTriggerConditionByTrigger);
//删除执行计划->删除计划&服务绑定
RepositoryEventBus.SubscribeSave <ITriggerRepository, ITriggerServerRepository, Trigger>(c => c.RemoveTriggerServerByTrigger);
//查询计划查询特定类型信息
RepositoryEventBus.SubscribeQuery <ITriggerRepository, ISimpleTriggerRepository, Trigger>(c => c.LoadSimpleTrigger);
RepositoryEventBus.SubscribeQuery <ITriggerRepository, IExpressionTriggerRepository, Trigger>(c => c.LoadExpressionTrigger);
#endregion
#endregion
}
