/// <summary>
/// 通过用户查询对象，查询用户信息
/// </summary>
/// <param name="criteria">用户查询对象</param>
/// <returns></returns>
public UserList GetByUserCriteria(UserCriteria criteria)
{
var cqc = new CommonQueryCriteria();
//Id
if (criteria.Id != null)
{
cqc.Add(new PropertyMatch(User.IdProperty, criteria.Id));
}
//登录名
if (!string.IsNullOrEmpty(criteria.UserName))
{
cqc.Add(new PropertyMatch(User.UserNameProperty, criteria.UserName));
}
//密码
if (!string.IsNullOrEmpty(criteria.Password))
{
cqc.Add(new PropertyMatch(User.PasswordProperty, criteria.Password));
}
//员工号
if (!string.IsNullOrEmpty(criteria.EmployeeNumber))
{
cqc.Add(new PropertyMatch(UserExt.EmployeeNumberProperty, criteria.EmployeeNumber));
}
return(this.Repository.GetBy(cqc));
}
private CommonQueryCriteria DesrializeCommonQueryCriteria(IValueProvider values)
{
var criteria = new CommonQueryCriteria();
if (values.ContainsPrefix("$orderby"))
{
var value = values.GetValue("$orderby");
criteria.OrderBy = value.AttemptedValue;
}
if (values.ContainsPrefix("$pageNumber"))
{
var pageNumber = (int)values.GetValue("$pageNumber").ConvertTo(typeof(int));
int pageSize = 10;
if (values.ContainsPrefix("$pageSize"))
{
pageSize = (int)values.GetValue("$pageSize").ConvertTo(typeof(int));
}
var pagingInfo = new PagingInfo(pageNumber, pageSize);
criteria.PagingInfo = pagingInfo;
}
//filter
//var jFilter = json.Property("$filter");
//if (jFilter != null)
//{
// var filter = jFilter.Value.Value<string>();
// ParseFilter(criteria, filter);
//}
return(criteria);
}
/// <summary>
/// 执行数据归档。
/// </summary>
public void ExecuteArchivingData()
{
var condition = new CommonQueryCriteria(BinaryOperator.And)
{
new PropertyMatch(EntityStampExtension.UpdatedTimeProperty, PropertyOperator.LessEqual, this._context.DateOfArchiving)
};
condition.PagingInfo = new PagingInfo(1, this._context.PageSize);
var aggregationRootParameters = _context.ArchivingAggregationRootTypeList;
this.Report(new DataTableMigrationEventArgs("-------------- 开始数据归档 --------------"));
foreach (var parameter in aggregationRootParameters)
{
var currentProcess = 0M;
var repository = this.FindRepository(parameter);
var totalCount = repository.CountBy(new CommonQueryCriteria {
new PropertyMatch(EntityStampExtension.UpdatedTimeProperty, PropertyOperator.LessEqual, this._context.DateOfArchiving)
});
this.Report(new DataTableMigrationEventArgs($"共有 {totalCount} 个聚合根 {parameter.FullName} 需要归档。"));
var eagerLoadOptions = new EagerLoadOptions();
bool isHasChild = false;
LoadChildListProperty(ref isHasChild, repository.EntityMeta, eagerLoadOptions);
bool isSupportTree = repository.SupportTree;
if (isSupportTree)
{
eagerLoadOptions.LoadWithTreeChildren();
}
if (isHasChild || isSupportTree)
{
condition.EagerLoad = eagerLoadOptions;
}
var entityList = repository.GetBy(condition);
while (entityList != null && entityList.Count > 0)
{
this.SaveToHistory(repository, entityList, isSupportTree);
//实体删除
this.RemoveOriginData(repository, entityList);
currentProcess = currentProcess + entityList.Count;
this.Report(new DataTableMigrationEventArgs($"\t处理进度", decimal.Round(currentProcess / totalCount * 100, 2)));
entityList = repository.GetBy(condition);
}
}
this.Report(new DataTableMigrationEventArgs("-------------- 结束数据归档 --------------"));
}
/// <summary>
/// 数据归档。
/// </summary>
/// <param name="pagingInfo">表示一个批次的分页信息。</param>
/// <param name="repository">当前对象对应的仓库。</param>
private void ArchivingDataCore(PagingInfo pagingInfo, IRepository repository)
{
var condition = new CommonQueryCriteria(BinaryOperator.And)
{
new PropertyMatch(EntityStampExtension.CreatedTimeProperty, PropertyOperator.LessEqual, this._context.DateOfArchiving)
};
condition.PagingInfo = pagingInfo;
var step = 1;
var entityList = repository.GetBy(condition);
while (entityList != null && entityList.Count > 0)
{
this.Report(new DataTableMigrationEventArgs($"批次 {step} 总数量", entityList.Count)
{
NeedNewLine = true
});
//
// TODO: {entityList} 存储到历史表里面
//
// this.SaveToHistory(entityList);
//this._needArchivingData.Clear();
this._archiveDataCache.Clear();
foreach (var entity in entityList)
{
entity.PersistenceStatus = PersistenceStatus.Deleted;
this.ArchivingReferenceData(entity, repository.EntityMeta);
this.Report(new DataTableMigrationEventArgs($"Archiving Completed. EntityId: {entity.Id}", step));
++step;
}
try
{
this._archiveDataCache = this._archiveDataCache.OrderByDescending(c => c.Level).ToList();
foreach (var archivingDataCahceInfo in this._archiveDataCache)
{
archivingDataCahceInfo.EntityList.ForEach(e => e.PersistenceStatus = PersistenceStatus.Deleted);
archivingDataCahceInfo.Repository.Save(archivingDataCahceInfo.EntityList);
}
//
// TODO: 批量删除原始表里面的数据
repository.Save(entityList);
//
}
catch (Exception exception)
{
throw new DataTableMigrationException("删除原始数据失败。", exception);
}
this.Report(new DataTableMigrationEventArgs($"-------------- 批次 {pagingInfo.PageNumber} 归档完成 --------------"));
}
}
private UserList GetIsDisabledUsers(object isDisabled, PagingInfo pi = null, EagerLoadOptions eagerLoad = null)
{
var criteria = new CommonQueryCriteria
{
new PropertyMatch(User.IsDisabledProperty, isDisabled)
};
criteria.PagingInfo = pi;
criteria.EagerLoad = eagerLoad;
return(this.GetBy(criteria));
}
public bool IsExistsByUserName(User user)
{
var cqc = new CommonQueryCriteria();
cqc.Add(new PropertyMatch(User.IdProperty, PropertyOperator.NotEqual, user.Id));
//登录名
if (!string.IsNullOrEmpty(user.UserName))
{
cqc.Add(new PropertyMatch(User.UserNameProperty, user.UserName));
}
var list = this.Repository.GetBy(cqc);
return(list != null && list.Count > 0);
}
public PurchaseOrderList GetBy(ClientTimeSpanCriteria criteria)
{
var c = new CommonQueryCriteria
{
new PropertyMatch(PurchaseOrder.DateProperty, PropertyOperator.GreaterEqual, criteria.From),
new PropertyMatch(PurchaseOrder.DateProperty, PropertyOperator.LessEqual, criteria.To),
};
if (criteria.ClientInfoId.HasValue)
{
c.Add(new PropertyMatch(PurchaseOrder.SupplierIdProperty, criteria.ClientInfoId.Value));
}
return(this.GetBy(c));
}
protected override void Validate(Entity entity, RuleArgs e)
{
var id = entity.Id;
var repo = RF.Find(ReferenceProperty.Owner);
if (repo != null)
{
var criteria = new CommonQueryCriteria();
criteria.Add(ReferenceProperty.Property, id);
var count = repo.CountBy(criteria);
if (count > 0)
{
e.BrokenDescription = this.BuildError(entity, count);
}
}
}
public UserList GetByUserNameAndEmployeeNumber(string userName, string employeeNumber)
{
var cqc = new CommonQueryCriteria(BinaryOperator.Or);
//登录名
if (!string.IsNullOrEmpty(userName))
{
cqc.Add(new PropertyMatch(User.UserNameProperty, userName));
}
//员工号
if (!string.IsNullOrEmpty(employeeNumber))
{
cqc.Add(new PropertyMatch(UserExt.EmployeeNumberProperty, employeeNumber));
}
return(this.Repository.GetBy(cqc));
}
/// <summary>
/// 获取指定的用户 <paramref name="user"/> 是否具有指定的角色 <paramref name="role"/> 。
/// </summary>
/// <param name="user">表示一个用户的实例。</param>
/// <param name="role">表示一个角色的实例。</param>
/// <returns>true: 指定的用户 <paramref name="user"/> 有指定的角色 <paramref name="role"/> ; false: 反之。</returns>
public virtual bool HasRole(User user, Role role)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (role == null)
{
throw new ArgumentNullException(nameof(role));
}
var condition = new CommonQueryCriteria(BinaryOperator.And)
{
new PropertyMatch(UserRole.UserIdProperty, PropertyOperator.Equal, user.Id),
new PropertyMatch(UserRole.RoleIdProperty, PropertyOperator.Equal, role.Id)
};
var userRole = this._userRoleRepository.GetFirstBy(condition);
return(userRole != null && userRole.RoleId > 0);
}
/// <summary>
/// 根据传入的属性列表，来构造 CommonQueryCriteria
/// 返回是否有非空属性需要验证。
/// </summary>
/// <param name="entity"></param>
/// <param name="criteria"></param>
/// <returns></returns>
private bool AddToCriteria(Entity entity, CommonQueryCriteria criteria)
{
bool hasValue = false;
foreach (IProperty property in this.Properties)
{
EnsurePropertyCategory(property);
var value = entity.GetProperty(property);
if (DomainHelper.IsNotEmpty(value))
{
hasValue = true;
criteria.Add(property, value);
}
}
if ((entity as IEntityWithId).IdProvider.IsAvailable(entity.Id))
{
criteria.Add(Entity.IdProperty, PropertyOperator.NotEqual, entity.Id);
}
return(hasValue);
}
/// <summary>
/// 根据传入的属性列表，来构造 CommonQueryCriteria
/// 返回是否有非空属性需要验证。
/// </summary>
/// <param name="entity"></param>
/// <param name="criteria"></param>
/// <returns></returns>
private bool AddToCriteria(Entity entity, CommonQueryCriteria criteria)
{
bool hasValue = false;
foreach (IProperty property in this.Properties)
{
EnsurePropertyCategory(property);
var value = entity.GetProperty(property);
if (ConditionalSql.IsNotEmpty(value))
{
hasValue = true;
criteria.Add(property, value);
}
}
if (entity.HasId)
{
criteria.Add(Entity.IdProperty, PropertyOperator.NotEqual, entity.Id);
}
return(hasValue);
}
/// <summary>
/// 限制实体的某一个或几个属性的值在数据库中不存在的规则。
/// </summary>
/// <param name="entity"></param>
/// <param name="e"></param>
protected override void Validate(Entity entity, RuleArgs e)
{
if (entity.PersistenceStatus == PersistenceStatus.New ||
entity.PersistenceStatus == PersistenceStatus.Modified)
{
this.InitProperties(e);
var criteria = new CommonQueryCriteria();
bool hasValue = this.AddToCriteria(entity, criteria);
if (hasValue)
{
//查询实体的个数，如果已经存在，则构造错误信息
var repo = entity.GetRepository();
var count = repo.CountBy(criteria);
if (count > 0)
{
e.BrokenDescription = BuildError(entity);
}
}
}
}
/// <summary>
/// 限制实体的某一个或几个属性的值在数据库中不存在的规则。
/// </summary>
/// <param name="entity"></param>
/// <param name="e"></param>
protected override void Validate(Entity entity, RuleArgs e)
{
if (entity.PersistenceStatus == PersistenceStatus.New ||
entity.PersistenceStatus == PersistenceStatus.Modified)
{
this.InitProperties(e);
var criteria = new CommonQueryCriteria();
bool hasValue = this.AddToCriteria(entity, criteria);
if (hasValue)
{
//查询实体的个数，如果已经存在，则构造错误信息
var repo = entity.GetRepository();
var count = repo.CountBy(criteria);
if (count > 0)
{
e.BrokenDescription = BuildError(entity);
}
}
}
}
private void StartArchivingTask(string entityTypeFullName)
{
ReferenceInfo referenceInfo;
if (!this._archivingEntity.TryGetValue(entityTypeFullName, out referenceInfo))
{
return;
}
var condition = new CommonQueryCriteria(BinaryOperator.And)
{
new PropertyMatch(EntityStampExtension.CreatedTimeProperty, PropertyOperator.LessEqual, this._context.DateOfArchiving)
};
var totalCount = referenceInfo.Repository.CountBy(condition);
this.Report(new DataTableMigrationEventArgs($"需要归档总数据量：{totalCount}")
{
NeedNewLine = true
});
var pagingInfo = new PagingInfo(1, this._context.PageSize);
this.ArchivingDataCore(pagingInfo, referenceInfo.Repository);
}
public new DbMigrationHistoryList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as DbMigrationHistoryList);
}
public new OperationACList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as OperationACList);
}
public new OrgPositionUserList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as OrgPositionUserList;
}
public new DbMigrationHistoryList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as DbMigrationHistoryList;
}
public new $domainEntityName$ GetFirstBy(CommonQueryCriteria criteria)
{
return base.GetFirstBy(criteria) as $domainEntityName$;
}
public new PBSTypeList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as PBSTypeList;
}
public new Book GetFirstBy(CommonQueryCriteria criteria)
{
return(base.GetFirstBy(criteria) as Book);
}
public new ScopeVersionList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as ScopeVersionList;
}
public new LesseeList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as LesseeList;
}
public new BookAdministratorList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as BookAdministratorList;
}
public new BuildingList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as BuildingList;
}
public new DList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as DList;
}
public new WeekCompletionList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as WeekCompletionList;
}
public new ChapterList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as ChapterList;
}
public new DbSettingItemList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as DbSettingItemList;
}
public new DataPermission GetFirstBy(CommonQueryCriteria criteria)
{
return(base.GetFirstBy(criteria) as DataPermission);
}
/// <summary>
/// 根据传入的属性列表，来构造 CommonQueryCriteria
/// 返回是否有非空属性需要验证。
/// </summary>
/// <param name="entity"></param>
/// <param name="criteria"></param>
/// <returns></returns>
private bool AddToCriteria(Entity entity, CommonQueryCriteria criteria)
{
bool hasValue = false;
foreach (IProperty property in this.Properties)
{
EnsurePropertyCategory(property);
var value = entity.GetProperty(property);
if (DomainHelper.IsNotEmpty(value))
{
hasValue = true;
criteria.Add(property, value);
}
}
if (entity.HasId)
{
criteria.Add(Entity.IdProperty, PropertyOperator.NotEqual, entity.Id);
}
return hasValue;
}
public new AChildList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as AChildList;
}
public new ProductAttachementList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as ProductAttachementList;
}
public new BookCategoryList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as BookCategoryList;
}
public new ScopeVersionList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as ScopeVersionList);
}
public new $domainEntityName$List GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as $domainEntityName$List;
}
public new StorageMoveItem GetFirstBy(CommonQueryCriteria criteria)
{
return(base.GetFirstBy(criteria) as StorageMoveItem);
}
public new MonthPlanList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as MonthPlanList;
}
public new SectionOwnerList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as SectionOwnerList;
}
public new WeekNote GetFirstBy(CommonQueryCriteria criteria)
{
return(base.GetFirstBy(criteria) as WeekNote);
}
protected override void Validate(Entity entity, RuleArgs e)
{
var id = entity.Id;
var repo = RF.Find(ReferenceProperty.Owner);
if (repo != null)
{
var criteria = new CommonQueryCriteria();
criteria.Add(ReferenceProperty.Property, id);
var count = repo.CountBy(criteria);
if (count > 0)
{
e.BrokenDescription = this.BuildError(entity, count);
}
}
}
public new StorageMoveItemList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as StorageMoveItemList);
}
public new StorageMoveItemList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as StorageMoveItemList;
}
public new ProductAttachementList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as ProductAttachementList);
}
public new OtherStorageInBillList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as OtherStorageInBillList;
}
public new OperationAC GetFirstBy(CommonQueryCriteria criteria)
{
return(base.GetFirstBy(criteria) as OperationAC);
}
public new BuildingList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as BuildingList);
}
public new OperationACList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as OperationACList;
}
public new C GetFirstBy(CommonQueryCriteria criteria)
{
return(base.GetFirstBy(criteria) as C);
}
public new DataPermissionList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as DataPermissionList);
}
public new AuditItemList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as AuditItemList;
}
public new OrgPositionOperationDenyList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as OrgPositionOperationDenyList;
}
public new TestRoleList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as TestRoleList;
}
public new CList GetBy(CommonQueryCriteria criteria)
{
return(base.GetBy(criteria) as CList);
}
public new AChild GetFirstBy(CommonQueryCriteria criteria)
{
return base.GetFirstBy(criteria) as AChild;
}
/// <summary>
/// 注册指定的用户。
/// </summary>
/// <param name="user"></param>
/// <returns></returns>
public virtual Result Register(User user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
var userNameAsId = _identityMode.HasFlag(UserIdentityMode.UserName);
if (userNameAsId && string.IsNullOrEmpty(user.UserName))
{
return(new Result(ResultCodes.RegisterUserNameInvalid, "用户名不能为空。"));
}
var emailAsId = _identityMode.HasFlag(UserIdentityMode.Email);
if (emailAsId && !TextFormatter.ReEmail.IsMatch(user.Email))
{
return(new Result(ResultCodes.RegisterEmailInvalid, "邮箱格式不正确。"));
}
if (!userNameAsId && !emailAsId)
{
throw new InvalidProgramException("!userNameAsId && !useEmailAsId");
}
//验证其它属性。
var brokenRules = Validator.Validate(user);
if (brokenRules.Count > 0)
{
return(new Result(ResultCodes.RegisterPropertiesInvalid, brokenRules.ToString()));
}
//检查用户名、邮箱的重复性。
var repo = RF.Concrete <UserRepository>();
var criteria = new CommonQueryCriteria();
criteria.Concat = BinaryOperator.Or;
if (userNameAsId)
{
criteria.Add(new PropertyMatch(User.UserNameProperty, user.UserName));
}
if (emailAsId)
{
criteria.Add(new PropertyMatch(User.EmailProperty, user.Email));
}
var exists = repo.GetFirstBy(criteria);
if (exists != null)
{
if (emailAsId && exists.Email == user.Email)
{
return(new Result(ResultCodes.RegisterEmailDuplicated, string.Format("注册失败，已经存在邮箱为：{0} 的用户。", user.Email)));
}
else
{
return(new Result(ResultCodes.RegisterUserNameDuplicated, string.Format("注册失败，已经存在用户名为：{0} 的用户。", user.UserName)));
}
}
//保存这个用户
user.PersistenceStatus = PersistenceStatus.New;
repo.Save(user);
this.OnRegisterSuccessed(user);
return(true);
}
public new ClientInfoList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as ClientInfoList;
}
public new Building GetFirstBy(CommonQueryCriteria criteria)
{
return(base.GetFirstBy(criteria) as Building);
}
public new DevLanguageItemList GetBy(CommonQueryCriteria criteria)
{
return base.GetBy(criteria) as DevLanguageItemList;
}
