/// <summary>
/// 用户授权筛选
/// </summary>
/// <param name="filter">筛选信息</param>
/// <returns></returns>
IQuery CreateAuthorityQueryObject(UserAuthorityFilterDto filter)
{
if (filter == null)
{
return(null);
}
IQuery query = CreateAuthorityQueryObject(filter, true) ?? QueryFactory.Create <AuthorityQuery>();
#region 用户授权筛选
if (filter.UserFilter != null)
{
IQuery userQuery = this.Instance <IUserBusiness>().CreateQueryObject(filter.UserFilter);
if (userQuery != null)
{
userQuery.AddQueryFields <UserQuery>(c => c.SysNo);
#region 用户或者角色绑定的授权
IQuery userOrRoleBindAuthQuery = QueryFactory.Create();
//用户授权
IQuery userAuthBindQuery = QueryFactory.Create <UserAuthorizeQuery>(c => c.Disable == false);
userAuthBindQuery.And <UserAuthorizeQuery>(c => c.User, CriteriaOperator.In, userQuery);
userAuthBindQuery.AddQueryFields <UserAuthorizeQuery>(c => c.Authority);
IQuery userAuthQuery = QueryFactory.Create <AuthorityQuery>();
userAuthQuery.And <AuthorityQuery>(c => c.Code, CriteriaOperator.In, userAuthBindQuery);
userOrRoleBindAuthQuery.And(userAuthQuery);
//角色授权
IQuery userRoleBindQuery = QueryFactory.Create <UserRoleQuery>();
userRoleBindQuery.And <UserRoleQuery>(c => c.UserSysNo, CriteriaOperator.In, userQuery);
userRoleBindQuery.AddQueryFields <UserRoleQuery>(c => c.RoleSysNo);
IQuery roleAuthBindQuery = QueryFactory.Create <RoleAuthorizeQuery>();
roleAuthBindQuery.And <RoleAuthorizeQuery>(c => c.Role, CriteriaOperator.In, userRoleBindQuery);
roleAuthBindQuery.AddQueryFields <RoleAuthorizeQuery>(c => c.Authority);
IQuery roleAuthQuery = QueryFactory.Create <AuthorityQuery>();
roleAuthQuery.And <AuthorityQuery>(c => c.Code, CriteriaOperator.In, roleAuthBindQuery);
userOrRoleBindAuthQuery.Or(roleAuthQuery);
query.And(userOrRoleBindAuthQuery);
#endregion
//排除用户禁用的授权
IQuery userDisableAuthQuery = QueryFactory.Create <UserAuthorizeQuery>(c => c.Disable == true);
userDisableAuthQuery.And <UserAuthorizeQuery>(c => c.User, CriteriaOperator.In, userQuery);
userDisableAuthQuery.AddQueryFields <UserAuthorizeQuery>(c => c.Authority);
query.And <AuthorityQuery>(c => c.Code, CriteriaOperator.NotIn, userDisableAuthQuery);
}
}
#endregion
return(query);
}
/// <summary>
/// 生成服务调度计划查询对象
/// </summary>
/// <param name="filter">查询信息</param>
/// <returns></returns>
IQuery CreateQueryObject(ServerScheduleTriggerFilterDto filter)
{
if (filter == null)
{
return(null);
}
IQuery triggerQuery = CreateQueryObject(filter, true) ?? QueryFactory.Create <TriggerQuery>();
#region 任务筛选
IQuery jobQuery = this.Instance <IJobBusiness>().CreateQueryObject(filter.JobFilter);
if (jobQuery != null && jobQuery.Criterias.Count > 0)
{
jobQuery.AddQueryFields <JobQuery>(c => c.Id);
triggerQuery.And <TriggerQuery>(c => c.Job, CriteriaOperator.In, jobQuery);
}
#endregion
#region 务筛选
IQuery serverQuery = this.Instance <IServerNodeBusiness>().CreateQueryObject(filter.ServerFilter);
if (serverQuery != null && serverQuery.Criterias.Count > 0)
{
IQuery triggerServerFilterQuery = QueryFactory.Create();
serverQuery.AddQueryFields <ServerNodeQuery>(c => c.Id);
IQuery triggerServerQuery = QueryFactory.Create <TriggerServerQuery>();
triggerServerQuery.And <TriggerServerQuery>(c => c.Server, CriteriaOperator.In, serverQuery);
triggerServerQuery.AddQueryFields <TriggerServerQuery>(c => c.Trigger);
triggerServerFilterQuery.And <TriggerQuery>(c => c.Id, CriteriaOperator.In, triggerServerQuery);
//服务承载任务针对所有的执行计划
IQuery serverJobHostQuery = QueryFactory.Create <JobServerHostQuery>();
serverJobHostQuery.And <JobServerHostQuery>(c => c.Server, CriteriaOperator.In, serverQuery);
serverJobHostQuery.AddQueryFields <JobServerHostQuery>(c => c.Job);
IQuery applyToAllServerQuery = QueryFactory.Create();
applyToAllServerQuery.And <TriggerQuery>(c => c.Job, CriteriaOperator.In, serverJobHostQuery);
applyToAllServerQuery.And <TriggerQuery>(c => c.ApplyTo == TaskTriggerApplyTo.所有);
triggerServerFilterQuery.Or(applyToAllServerQuery);
triggerQuery.And(triggerServerFilterQuery);
}
#endregion
return(triggerQuery);
}
/// <summary>
/// Remove Objects
/// </summary>
/// <param name="entityList">datas</param>
protected async Task RemoveAsync(IEnumerable <ET> entityList)
{
Type entityType = typeof(ET);
var keys = QueryConfig.GetPrimaryKeys(entityType);
if (keys.IsNullOrEmpty())
{
throw new Exception(string.Format("Type:{0} isn't set primary keys", entityType.FullName));
}
IQuery query = QueryFactory.Create();
List <dynamic> keyValueList = new List <dynamic>();
foreach (ET entity in entityList)
{
if (keys.Count == 1)
{
keyValueList.Add(entity.GetPropertyValue(keys.ElementAt(0)));
}
else
{
IQuery entityQuery = QueryFactory.Create();
foreach (var key in keys)
{
entityQuery.And(key, CriteriaOperator.Equal, entity.GetPropertyValue(key));
}
query.Or(entityQuery);
}
}
if (keys.Count == 1)
{
query.In(keys.ElementAt(0), keyValueList);
}
UnitOfWork.UnitOfWork.RegisterCommand(await dataAccess.DeleteAsync(query).ConfigureAwait(false));
}
/// <summary>
/// 管理用户查询对象
/// </summary>
/// <param name="adminUserFilter">管理用户筛选对象</param>
/// <returns></returns>
public IQuery CreateAdminQueryObject(AdminUserFilterDto adminUserFilter)
{
if (adminUserFilter == null)
{
return(null);
}
IQuery userQuery = CreateQueryObject(adminUserFilter, true) ?? QueryFactory.Create <UserQuery>();
#region 角色筛选
if (adminUserFilter.RoleFilter != null)
{
IQuery roleQuery = this.Instance <IRoleBusiness>().CreateQueryObject(adminUserFilter.RoleFilter);
if (roleQuery != null && roleQuery.Criterias.Count > 0)
{
roleQuery.AddQueryFields <RoleQuery>(c => c.SysNo);
IQuery userRoleQuery = QueryFactory.Create <UserRoleQuery>();
userRoleQuery.And <UserRoleQuery>(u => u.RoleSysNo, CriteriaOperator.In, roleQuery);
userRoleQuery.AddQueryFields <UserRoleQuery>(u => u.UserSysNo);
userQuery.And <UserQuery>(c => c.SysNo, CriteriaOperator.In, userRoleQuery);
}
}
#endregion
return(userQuery);
}
/// <summary>
/// Creates the entities supplied conditionally based on whether it exists in the datastore.
/// Existance in the datastore is done by finding any entities w/ matching values for the
/// <paramref name="checkFields"/> supplied.
/// </summary>
/// <param name="entity">Entity to create.</param>
/// <param name="checkFields">Matching filters.</param>
public virtual void Create(T entity, params Expression <Func <T, object> >[] checkFields)
{
if (checkFields == null || checkFields.Length == 0)
{
Create(entity);
return;
}
IQuery <T> criteria = Query <T> .New();
string propName = ExpressionHelper.GetPropertyName <T>(checkFields[0]);
PropertyInfo prop = entity.GetType().GetProperty(propName);
object propVal = Reflection.ReflectionUtils.GetPropertyValueSafely(entity, prop);
criteria.Where(propName).Is(propVal);
if (checkFields.Length > 1)
{
for (int ndx = 1; ndx < checkFields.Length; ndx++)
{
propName = ExpressionHelper.GetPropertyName <T>(checkFields[ndx]);
prop = entity.GetType().GetProperty(propName);
propVal = Reflection.ReflectionUtils.GetPropertyValueSafely(entity, prop);
criteria.And(propName).Is(propVal);
}
}
// Only create if it doesn't exist.
int count = Count(criteria);
if (count == 0)
{
Create(entity);
}
}
/// <summary>
/// 根据用户查询操作授权的功能
/// </summary>
/// <param name="filter">筛选条件</param>
/// <returns></returns>
IQuery CreateAuthorityOperationQueryObject(UserOperationFilterDto filter)
{
if (filter == null)
{
return(null);
}
IQuery query = CreateAuthorityOperationQueryObject(filter, true) ?? QueryManager.Create <AuthorityOperationQuery>();
//用户授权的操作或者无限制的操作
var authAndUnlimitedOperationQuery = QueryManager.Create <AuthorityOperationQuery>();
if (filter.UserFilter != null)
{
//用户权限
var userAuthorityQuery = CreateUserAuthorityQueryObject(new UserAuthorityFilterDto()
{
UserFilter = filter.UserFilter,
Status = AuthorityStatus.启用
});
//权限绑定操作
var authBindOperationQuery = QueryManager.Create <AuthorityBindOperationQuery>();
authBindOperationQuery.EqualInnerJoin(userAuthorityQuery);
authBindOperationQuery.AddQueryFields <AuthorityBindOperationQuery>(a => a.AuthorityOperationSysNo);
authAndUnlimitedOperationQuery.In <AuthorityOperationQuery>(a => a.SysNo, authBindOperationQuery);
}
authAndUnlimitedOperationQuery.Or <AuthorityOperationQuery>(a => a.AuthorizeType == AuthorityOperationAuthorizeType.无限制);//无限制功能
query.And(authAndUnlimitedOperationQuery);
return(query);
}
/// <summary>
/// 授权操作绑定权限筛选
/// </summary>
/// <param name="filter">筛选对象</param>
/// <returns></returns>
IQuery CreateAuthorityQueryObject(AuthorityOperationBindAuthorityFilterDto filter)
{
if (filter == null)
{
return(null);
}
IQuery query = CreateAuthorityQueryObject(filter, true) ?? QueryFactory.Create <AuthorityQuery>();
#region 授权操作筛选
if (filter.AuthorityOperationFilter != null)
{
IQuery operationQuery = CreateAuthorityOperationQueryObject(filter.AuthorityOperationFilter);
if (operationQuery != null)
{
operationQuery.AddQueryFields <AuthorityOperationQuery>(c => c.SysNo);
IQuery authBindOperationQuery = QueryFactory.Create <AuthorityBindOperationQuery>();
authBindOperationQuery.And <AuthorityBindOperationQuery>(c => c.AuthorithOperation, CriteriaOperator.In, operationQuery);
authBindOperationQuery.AddQueryFields <AuthorityBindOperationQuery>(c => c.AuthorityCode);
query.And <AuthorityQuery>(c => c.Code, CriteriaOperator.In, authBindOperationQuery);
}
}
#endregion
return(query);
}
/// <summary>
/// 角色权限筛选
/// </summary>
/// <param name="filter">筛选信息</param>
/// <returns></returns>
IQuery CreateAuthorityQueryObject(RoleAuthorityFilterDto filter)
{
if (filter == null)
{
return(null);
}
IQuery query = CreateAuthorityQueryObject(filter, true) ?? QueryFactory.Create <AuthorityQuery>();
#region 角色授权筛选
if (filter.RoleFilter != null)
{
IQuery roleFilter = this.Instance <IRoleBusiness>().CreateQueryObject(filter.RoleFilter);
if (roleFilter != null)
{
roleFilter.AddQueryFields <RoleQuery>(c => c.SysNo);
IQuery roleBindAuthQuery = QueryFactory.Create <RoleAuthorizeQuery>();
roleBindAuthQuery.And <RoleAuthorizeQuery>(c => c.Role, CriteriaOperator.In, roleFilter);
roleBindAuthQuery.AddQueryFields <RoleAuthorizeQuery>(c => c.Authority);
query.And <AuthorityQuery>(c => c.Code, CriteriaOperator.In, roleBindAuthQuery);
}
}
#endregion
return(query);
}
/// <summary>
/// 创建查询对象
/// </summary>
/// <returns>返回查询对象</returns>
public override IQuery CreateQuery()
{
IQuery query = base.CreateQuery() ?? QueryManager.Create <PermissionGroupEntity>(this);
if (LevelOne)
{
query.And <PermissionGroupEntity>(c => c.Parent <= 0);
}
if (!Ids.IsNullOrEmpty())
{
query.And <PermissionGroupEntity>(c => Ids.Contains(c.Id));
}
if (!ExcludeIds.IsNullOrEmpty())
{
query.And <PermissionGroupEntity>(c => !ExcludeIds.Contains(c.Id));
}
if (!string.IsNullOrWhiteSpace(Name))
{
query.And <PermissionGroupEntity>(c => c.Name == Name);
}
if (Sort.HasValue)
{
query.And <PermissionGroupEntity>(c => c.Sort == Sort.Value);
}
if (Parent.HasValue)
{
query.And <PermissionGroupEntity>(c => c.Parent == Parent.Value);
}
if (!string.IsNullOrWhiteSpace(Remark))
{
query.And <PermissionGroupEntity>(c => c.Remark == Remark);
}
return(query);
}
/// <summary>
/// 管理用户查询对象
/// </summary>
/// <param name="adminUserFilter">管理用户筛选对象</param>
/// <returns></returns>
public IQuery CreateAdminQueryObject(AdminUserFilterDto adminUserFilter)
{
if (adminUserFilter == null)
{
return(null);
}
IQuery userQuery = CreateQueryObject(adminUserFilter, true) ?? QueryFactory.Create <UserQuery>();
#region 角色筛选
if (adminUserFilter.RoleFilter != null)
{
IQuery roleQuery = this.Instance <IRoleBusiness>().CreateQueryObject(adminUserFilter.RoleFilter);
if (roleQuery != null && roleQuery.Criterias.Count > 0)
{
roleQuery.AddQueryFields <RoleQuery>(c => c.SysNo);
IQuery userRoleQuery = QueryFactory.Create <UserRoleQuery>();
userRoleQuery.And <UserRoleQuery>(u => u.RoleSysNo, CriteriaOperator.In, roleQuery);
userRoleQuery.AddQueryFields <UserRoleQuery>(u => u.UserSysNo);
userQuery.And <UserQuery>(c => c.SysNo, CriteriaOperator.In, userRoleQuery);
}
}
if (!adminUserFilter.WithoutRoles.IsNullOrEmpty())
{
IQuery withRoleQuery = QueryFactory.Create <UserRoleQuery>();
withRoleQuery.In <UserRoleQuery>(r => r.RoleSysNo, adminUserFilter.WithoutRoles);
withRoleQuery.AddQueryFields <UserRoleQuery>(r => r.UserSysNo);
userQuery.And <UserQuery>(u => u.SysNo, CriteriaOperator.NotIn, withRoleQuery);
}
#endregion
#region 加载数据
if (adminUserFilter.LoadRole)
{
userQuery.SetLoadPropertys <AdminUser>(true, c => c.Roles);
}
#endregion
return(userQuery);
}
/// <summary>
/// Create a new query instance
/// </summary>
/// <typeparam name="T">data type</typeparam>
/// <param name="criteria">condition expression</param>
/// <returns>IQuery object</returns>
public static IQuery Create <T>(Expression <Func <T, bool> > criteria) where T : QueryModel <T>
{
IQuery query = Create <T>();
if (criteria != null)
{
query.And(criteria);
}
return(query);
}
/// <summary>
/// Modify data
/// </summary>
/// <param name="newData">New data</param>
/// <param name="oldData">Old data</param>
/// <param name="query">Query object</param>
/// <returns>Return command</returns>
public ICommand Modify(TEntity newData, TEntity oldData, IQuery query)
{
Dictionary <string, dynamic> modifyValues = newData.GetModifyValues(oldData);
if (modifyValues == null || modifyValues.Count < 1)
{
return(null);
}
if (query == null)
{
throw new EZNEWException("the data modification condition is null");
}
#region control version
string versionFieldName = EntityManager.GetVersionField(entityType);
if (!string.IsNullOrWhiteSpace(versionFieldName))
{
var nowVersionValue = newData.GetPropertyValue(versionFieldName);
if (!modifyValues.ContainsKey(versionFieldName))
{
var newVersionValue = nowVersionValue + 1;
newData.SetPropertyValue(versionFieldName, newVersionValue);
modifyValues.Add(versionFieldName, newVersionValue);
}
query.And(versionFieldName, CriteriaOperator.Equal, nowVersionValue);
}
#endregion
#region refresh date
string refreshFieldName = EntityManager.GetRefreshDateField(entityType);
if (!string.IsNullOrWhiteSpace(refreshFieldName))
{
if (!modifyValues.ContainsKey(refreshFieldName))
{
var nowDate = DateTimeOffset.Now;
newData.SetPropertyValue(refreshFieldName, nowDate);
modifyValues.Add(refreshFieldName, nowDate);
}
}
#endregion
var originValues = oldData.GetAllPropertyValues();
var command = ExecuteModifyData(originValues, modifyValues, query);
//publish modify data event
DataAccessEventBus.PublishModifyDataEvent <TEntity>(originValues, modifyValues, query);
return(command);
}
/// <summary>
/// 加载操作对应的权限信息
/// </summary>
/// <returns></returns>
List<Authority> LoadAuthority()
{
if (!AllowLazyLoad(r => r.Authoritys))
{
return _authoritys.CurrentValue;
}
IQuery query = QueryFactory.Create();
IQuery bindQuery = QueryFactory.Create(AuthorityBindOperationQuery.ObjectName);
bindQuery.AddQueryFields<AuthorityBindOperationQuery>(a => a.AuthorityCode);
bindQuery.And<AuthorityBindOperationQuery>(a => a.AuthorithOperation == _sysNo);
query.And<AuthorityQuery>(a => a.Code, CriteriaOperator.In, bindQuery);
return this.Instance<IAuthorityRepository>().GetList(query);
}
/// <summary>
/// 加载操作对应的权限信息
/// </summary>
/// <returns></returns>
List <Authority> LoadAuthority()
{
if (!AllowLazyLoad(r => r.Authoritys))
{
return(authoritys.CurrentValue);
}
IQuery query = QueryManager.Create();
IQuery bindQuery = QueryManager.Create <AuthorityBindOperationQuery>();
bindQuery.AddQueryFields <AuthorityBindOperationQuery>(a => a.AuthoritySysNo);
bindQuery.And <AuthorityBindOperationQuery>(a => a.AuthorityOperationSysNo == SysNo);
query.And <AuthorityQuery>(a => a.Code, CriteriaOperator.In, bindQuery);
return(this.Instance <IAuthorityRepository>().GetList(query));
}
/// <summary>
/// 验证用户名是否存在
/// </summary>
/// <param name="userName">用户名</param>
/// <param name="excludeId">检查除指定用户以外的用户信息</param>
/// <returns>返回用户名是否存在</returns>
public bool ExistName(string userName, long?excludeId = null)
{
if (string.IsNullOrWhiteSpace(userName))
{
return(false);
}
IQuery query = QueryManager.Create <UserEntity>(c => c.UserName == userName);
if (excludeId.HasValue)
{
query.And <UserEntity>(c => c.Id != excludeId);
}
return(userRepository.Exist(query));
}
public void BracketsOnLogicalOp()
{
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("CHAR") == "AAA" | val.of("CHAR") == "BBB" | val.of("CHAR") == "CCC");
Assert.AreEqual("(CHAR = AAA OR CHAR = BBB OR CHAR = CCC)", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("CHAR") == "AAA" & val.of("CHAR") == "BBB" | val.of("CHAR") == "CCC");
Assert.AreEqual("(CHAR = AAA AND CHAR = BBB OR CHAR = CCC)", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("CHAR") == "AAA" | val.of("CHAR") == "BBB" & val.of("CHAR") == "CCC");
Assert.AreEqual("(CHAR = AAA OR CHAR = BBB AND CHAR = CCC)", aQuery.GetWhereExp());
}
/// <summary>
/// Create a new query instance
/// </summary>
/// <typeparam name="T">data type</typeparam>
/// <param name="criteria">condition expression</param>
/// <param name="objectName">object name</param>
/// <returns>IQuery object</returns>
public static IQuery Create <T>(Expression <Func <T, bool> > criteria, string objectName = "") where T : IQueryModel <T>
{
if (string.IsNullOrWhiteSpace(objectName))
{
objectName = QueryModel <T> .QueryObjectName;
}
IQuery query = Create(objectName);
if (criteria != null)
{
query.And <T>(criteria);
}
return(query);
}
/// <summary>
/// 验证用户名是否存在
/// </summary>
/// <param name="userName">用户名</param>
/// <param name="excludeUserId">检查除指定用户以外的用户信息</param>
/// <returns></returns>
public bool ExistUserName(string userName, long?excludeUserId = null)
{
if (userName.IsNullOrEmpty())
{
return(false);
}
IQuery query = QueryFactory.Create <UserQuery>(c => c.UserName == userName);
if (excludeUserId.HasValue)
{
query.And <UserQuery>(c => c.SysNo != excludeUserId);
}
return(userRepository.Exist(query));
}
/// <summary>
/// 根据查询条件生成查询对象
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
IQuery CreateQueryObject(JobServerHostFilterDto filter)
{
if (filter == null)
{
return(null);
}
IQuery query = QueryFactory.Create(filter);
if (!filter.Servers.IsNullOrEmpty())
{
query.In <JobServerHostQuery>(c => c.Server, filter.Servers);
}
if (!filter.Jobs.IsNullOrEmpty())
{
query.In <JobServerHostQuery>(c => c.Job, filter.Jobs);
}
if (filter.RunStatus.HasValue)
{
query.Equal <JobServerHostQuery>(c => c.RunStatus, filter.RunStatus.Value);
}
if (!filter.ServerKey.IsNullOrEmpty())
{
IQuery serverQuery = QueryFactory.Create <ServerNodeQuery>();
serverQuery.And <ServerNodeQuery>(QueryOperator.OR, CriteriaOperator.Like, filter.ServerKey, null, c => c.Name, c => c.Host);
serverQuery.AddQueryFields <ServerNodeQuery>(c => c.Id);
query.And <JobServerHostQuery>(c => c.Server, CriteriaOperator.In, serverQuery);
}
if (!filter.JobKey.IsNullOrEmpty())
{
IQuery jobQuery = QueryFactory.Create <JobQuery>();
jobQuery.And <JobQuery>(QueryOperator.OR, CriteriaOperator.Like, filter.JobKey, null, c => c.Name);
jobQuery.AddQueryFields <JobQuery>(c => c.Id);
query.And <JobServerHostQuery>(c => c.Job, CriteriaOperator.In, jobQuery);
}
return(query);
}
/// <summary>
/// Append Entity Identity Condition
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="datas">datas</param>
/// <param name="originalQuery">original query</param>
/// <param name="exclude">exclude</param>
/// <returns></returns>
public static IQuery AppendEntityIdentityCondition <T>(IEnumerable <T> datas, IQuery originalQuery = null, bool exclude = false) where T : BaseEntity <T>
{
originalQuery = originalQuery ?? QueryFactory.Create();
if (datas == null || !datas.Any())
{
return(originalQuery);
}
var entityType = typeof(T);
var keys = EntityManager.GetPrimaryKeys(entityType);
if (keys.IsNullOrEmpty())
{
throw new Exception(string.Format("type:{0} isn't set primary keys", entityType.FullName));
}
var firstData = datas.ElementAt(0).GetPropertyValue(keys.ElementAt(0));
var dataType = firstData.GetType();
dynamic keyValueList = Activator.CreateInstance(typeof(List <>).MakeGenericType(dataType));
//List<dynamic> keyValueList = new List<dynamic>();
foreach (T entity in datas)
{
if (keys.Count == 1)
{
keyValueList.Add(entity.GetPropertyValue(keys.ElementAt(0)));
}
else
{
IQuery entityQuery = Create();
foreach (var key in keys)
{
entityQuery.And(key, exclude ? CriteriaOperator.NotEqual : CriteriaOperator.Equal, entity.GetPropertyValue(key));
}
originalQuery.Or(entityQuery);
}
}
if (keys.Count == 1)
{
if (exclude)
{
originalQuery.NotIn(keys.ElementAt(0), keyValueList);
}
else
{
originalQuery.In(keys.ElementAt(0), keyValueList);
}
}
return(originalQuery);
}
/// <summary>
/// edit data
/// </summary>
/// <param name="newData">new data</param>
/// <param name="oldData">old data</param>
/// <param name="query">query object</param>
/// <returns>ICommand object</returns>
public virtual async Task <ICommand> ModifyAsync(T newData, T oldData, IQuery query)
{
Dictionary <string, dynamic> modifyValues = newData.GetModifyValues(oldData);
if (modifyValues == null || modifyValues.Count <= 0)
{
return(null);
}
if (query == null)
{
throw new EZNEWException("the data modification condition is null");
}
#region control version
string versionFieldName = EntityManager.GetVersionField(entityType);
if (!string.IsNullOrWhiteSpace(versionFieldName))
{
var nowVersionValue = newData.GetPropertyValue(versionFieldName);
if (!modifyValues.ContainsKey(versionFieldName))
{
var newVersionValue = nowVersionValue + 1;
newData.SetPropertyValue(versionFieldName, newVersionValue);
modifyValues.Add(versionFieldName, newVersionValue);
}
query.And(versionFieldName, CriteriaOperator.Equal, nowVersionValue);
}
#endregion
#region update date
string refreshFieldName = EntityManager.GetRefreshDateField(entityType);
if (!string.IsNullOrWhiteSpace(refreshFieldName))
{
if (!modifyValues.ContainsKey(refreshFieldName))
{
var nowDate = DateTime.Now;
newData.SetPropertyValue(refreshFieldName, nowDate);
modifyValues.Add(refreshFieldName, nowDate);
}
}
#endregion
return(await UpdateAsync(modifyValues.Keys, modifyValues, query).ConfigureAwait(false));
}
public void TestAnd()
{
Expression <Func <AggregateRootSample, bool> > expression = null;
_query.And(expression);
_query.And(t => t.Name == "A");
Assert.Equal("t => (t.Name == \"A\")", _query.GetPredicate().ToString());
_query.And(t => t.Tel == 1);
Assert.Equal("t => ((t.Name == \"A\") AndAlso (t.Tel == 1))", _query.GetPredicate().ToString());
}
public void LogicalOp()
{
//AND
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("NUM").Between(1, 9) & val.of("CHAR").Between("abc", "xyz"));
Assert.AreEqual("NUM BETWEEN 1 AND 9 AND CHAR BETWEEN abc AND xyz", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("NUM").In(1, 2, 3) & val.of("CHAR").In("abc", "def", "ghi"));
Assert.AreEqual("NUM IN (1, 2, 3) AND CHAR IN (abc, def, ghi)", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("NUM") != val.of("and") & val.of("CHAR") != val.of("or"));
Assert.AreEqual("NUM <> \"and\" AND CHAR <> \"or\"", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("NUM") == 1 & val.of("CHAR") == "a" & val.of("CHAR") == "a" & val.of("CHAR") == "a" & val.of("CHAR") == "a" & val.of("CHAR") == "a");
Assert.AreEqual("NUM = 1 AND CHAR = a AND CHAR = a AND CHAR = a AND CHAR = a AND CHAR = a", aQuery.GetWhereExp());
}
public void NullOperand()
{
val nullVal = null;
//AND
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("NUM") == 10 & null);
Assert.AreEqual("NUM = 10", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(null & val.of("NUM") == 10);
Assert.AreEqual("NUM = 10", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
//aQuery.And(nullVal And nullVal)
Assert.AreEqual("", aQuery.GetWhereExp());
//OR
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("NUM") == 10 | null);
Assert.AreEqual("NUM = 10", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(null | val.of("NUM") == 10);
Assert.AreEqual("NUM = 10", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
//aQuery.And(nullVal Or nullVal)
Assert.AreEqual("", aQuery.GetWhereExp());
//XOR
aQuery = new Query <ColumnInfo>();
aQuery.And(val.of("NUM") == 10 ^ null);
Assert.AreEqual("NUM = 10", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
aQuery.And(null ^ val.of("NUM") == 10);
Assert.AreEqual("NUM = 10", aQuery.GetWhereExp());
aQuery = new Query <ColumnInfo>();
//aQuery.And(nullVal Xor nullVal)
Assert.AreEqual("", aQuery.GetWhereExp());
}
public void Seriaraizable()
{
aQuery = new Query <Person>();
aQuery.MaxRows(7);
aQuery.RowRange(8, 9);
aQuery.OrderBy("id", "name", "birthDay");
aQuery.And(val.of("name") == "源頼朝" &
val.of("birthDay") != DateTime.Now &
!(val.of("id").In(1, 2, 3) | val.of("id").Between(1, 3)) ^
val.of("name").Like("源%") &
(val.of("birthDay") < DateTime.Now |
val.of("birthDay") <= DateTime.Now |
val.of("birthDay") > DateTime.Now |
val.of("birthDay") <= DateTime.Now));
this.Serialize(aQuery);
aQuery = null;
aQuery = (Query <Person>) this.Deserialize();
}
/// <summary>
/// Append Entity Identity Condition
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="data"></param>
/// <param name="originalQuery"></param>
/// <param name="exclude"></param>
/// <returns></returns>
public static IQuery AppendEntityIdentityCondition <T>(T data, IQuery originalQuery = null, bool exclude = false) where T : BaseEntity <T>
{
originalQuery = originalQuery ?? QueryFactory.Create();
if (data == null)
{
return(originalQuery);
}
Type entityType = typeof(T);
var keys = EntityManager.GetPrimaryKeys(entityType);
if (keys.IsNullOrEmpty())
{
throw new Exception(string.Format("type:{0} is not set primary keys", entityType.FullName));
}
foreach (var key in keys)
{
originalQuery.And(key, exclude ? CriteriaOperator.NotEqual : CriteriaOperator.Equal, data.GetPropertyValue(key));
}
return(originalQuery);
}
/// <summary>
/// 修改用户授权
/// </summary>
/// <param name="userAuthorizes">用户授权信息</param>
/// <returns></returns>
public static Result ModifyUserAuthorize(IEnumerable <UserAuthorize> userAuthorizes)
{
if (userAuthorizes.IsNullOrEmpty())
{
return(Result.FailedResult("没有指定任何要修改的用户授权信息"));
}
#region 角色授权
List <long> userIds = userAuthorizes.Select(c => c.User?.SysNo ?? 0).Distinct().ToList();
IQuery userRoleBindQuery = QueryFactory.Create <UserRoleQuery>(c => userIds.Contains(c.UserSysNo));
userRoleBindQuery.AddQueryFields <UserRoleQuery>(c => c.RoleSysNo);
IQuery roleAuthBindQuery = QueryFactory.Create <RoleAuthorizeQuery>();
roleAuthBindQuery.And <RoleAuthorizeQuery>(c => c.Role, CriteriaOperator.In, userRoleBindQuery);
roleAuthBindQuery.AddQueryFields <RoleAuthorizeQuery>(c => c.Authority);
IQuery authQuery = QueryFactory.Create <AuthorityQuery>();
authQuery.And <AuthorityQuery>(c => c.Code, CriteriaOperator.In, roleAuthBindQuery);
authQuery.AddQueryFields <AuthorityQuery>(c => c.Code);
IEnumerable <Authority> roleAuthoritys = AuthorityService.GetAuthorityList(authQuery);
List <string> roleAuthorityCodes = roleAuthoritys.Select(c => c.Code).ToList();
#endregion
List <UserAuthorize> saveUserAuthorizes = new List <UserAuthorize>();
userAuthRepository.Remove(userAuthorizes.ToArray()); //移除授权数据
List <UserAuthorize> disableAuthorizes = userAuthorizes.Where(c => c.Disable && roleAuthorityCodes.Contains(c.Authority?.Code)).ToList(); //角色拥有但是用户显示禁用掉的授权
if (!disableAuthorizes.IsNullOrEmpty())
{
saveUserAuthorizes.AddRange(disableAuthorizes);
}
List <UserAuthorize> enableAuthorizes = userAuthorizes.Where(c => !c.Disable && !roleAuthorityCodes.Contains(c.Authority?.Code)).ToList();//用户单独授权的权限
if (!enableAuthorizes.IsNullOrEmpty())
{
saveUserAuthorizes.AddRange(enableAuthorizes);
}
if (!saveUserAuthorizes.IsNullOrEmpty())
{
userAuthRepository.Save(saveUserAuthorizes.ToArray());
}
return(Result.SuccessResult("修改成功"));
}
/// <summary>
/// edit data
/// </summary>
/// <param name="obj">object</param>
/// <param name="query">query object</param>
/// <returns>ICommand object</returns>
public virtual ICommand Modify(T obj, IQuery query)
{
Dictionary <string, dynamic> modifyValues = obj.GetModifyValues();
if (modifyValues == null || modifyValues.Count <= 0)
{
return(null);
}
#region 版本控制
string versionFieldName = QueryConfig.GetVersionField(typeof(T));
if (!string.IsNullOrWhiteSpace(versionFieldName))
{
if (!modifyValues.ContainsKey(versionFieldName))
{
modifyValues.Add(versionFieldName, obj.PropertyValues[versionFieldName] + 1);
}
query = query ?? QueryFactory.Create();
query.And(versionFieldName, CriteriaOperator.Equal, obj.PropertyValues[versionFieldName]);
}
#endregion
#region 更新时间
string refreshFieldName = QueryConfig.GetRefreshDateField(typeof(T));
if (!string.IsNullOrWhiteSpace(refreshFieldName))
{
if (!modifyValues.ContainsKey(refreshFieldName))
{
modifyValues.Add(refreshFieldName, DateTime.Now);
}
}
#endregion
return(Update(modifyValues.Keys, modifyValues, query));
}
/// <summary>
/// 根据筛选条件创建查询对象
/// </summary>
/// <returns>返回查询对象</returns>
public override IQuery CreateQuery()
{
IQuery query = base.CreateQuery() ?? QueryManager.Create <OperationEntity>(this);
//用户授权的操作或者无限制的操作
var publicOrUserOperationQuery = QueryManager.Create <OperationEntity>();
if (UserFilter != null)
{
//用户权限
var userPermissionQuery = new UserPermissionFilter()
{
UserFilter = UserFilter,
Status = PermissionStatus.Enable
}.CreateQuery();
//权限绑定操作
var userPermissionOperationQuery = QueryManager.Create <PermissionOperationEntity>();
userPermissionOperationQuery.EqualInnerJoin(userPermissionQuery);
userPermissionOperationQuery.AddQueryFields <PermissionOperationEntity>(p => p.OperationId);
publicOrUserOperationQuery.In <OperationEntity>(c => c.Id, userPermissionOperationQuery);
}
publicOrUserOperationQuery.Or <OperationEntity>(a => a.AccessLevel == OperationAccessLevel.Public);//无限制功能
query.And(publicOrUserOperationQuery);
return(query);
}
/// <summary>
/// 根据权限查询条件生成查询对象
/// </summary>
/// <param name="filter">查询条件</param>
/// <returns></returns>
IQuery CreateAuthorityQueryObject(AuthorityFilterDto filter, bool useBaseFilter = false)
{
if (filter == null)
{
return(null);
}
IQuery query = null;
if (useBaseFilter)
{
query = QueryFactory.Create <AuthorityQuery>(filter);
#region 数据筛选
if (!filter.Codes.IsNullOrEmpty())
{
query.In <AuthorityQuery>(c => c.Code, filter.Codes);
}
if (!filter.Name.IsNullOrEmpty())
{
query.Equal <AuthorityQuery>(c => c.Name, filter.Name);
}
if (!filter.NameCodeMateKey.IsNullOrEmpty())
{
query.And <AuthorityQuery>(QueryOperator.OR, CriteriaOperator.Like, filter.NameCodeMateKey, null, a => a.Code, a => a.Name);
}
if (filter.AuthType.HasValue)
{
query.Equal <AuthorityQuery>(c => c.AuthType, filter.AuthType.Value);
}
if (filter.Status.HasValue)
{
query.Equal <AuthorityQuery>(c => c.Status, filter.Status.Value);
}
if (filter.Sort.HasValue)
{
query.Equal <AuthorityQuery>(c => c.Sort, filter.Sort.Value);
}
if (filter.AuthGroup.HasValue)
{
query.Equal <AuthorityQuery>(c => c.AuthGroup, filter.AuthGroup.Value);
}
if (!filter.Remark.IsNullOrEmpty())
{
query.Equal <AuthorityQuery>(c => c.Remark, filter.Remark);
}
//if (!filter.Application.IsNullOrEmpty())
//{
// query.Equal<AuthorityQuery>(c => c.Application, filter.Application);
//}
if (filter.CreateDate.HasValue)
{
query.Equal <AuthorityQuery>(c => c.CreateDate, filter.CreateDate.Value);
}
#endregion
#region 数据加载
if (filter.LoadGroup)
{
query.SetLoadPropertys <Authority>(true, c => c.AuthGroup);
}
#endregion
}
else
{
if (filter is AuthorityOperationBindAuthorityFilterDto)
{
query = CreateAuthorityQueryObject(filter as AuthorityOperationBindAuthorityFilterDto);//操作授权
}
else if (filter is RoleAuthorityFilterDto)
{
query = CreateAuthorityQueryObject(filter as RoleAuthorityFilterDto);//角色授权
}
else if (filter is UserAuthorityFilterDto)
{
query = CreateAuthorityQueryObject(filter as UserAuthorityFilterDto);//用户授权
}
else
{
query = CreateAuthorityQueryObject(filter, true);
}
}
return(query);
}
