public virtual async Task CreateAsync(OrganizationUnit organizationUnit)
{
organizationUnit.Code = await GetNextChildCodeAsync(organizationUnit.ParentId);
await ValidateOrganizationUnitAsync(organizationUnit);
await OrganizationUnitRepository.InsertAsync(organizationUnit);
}
public virtual async Task MoveAsync(long id, long?parentId)
{
using (var uow = UnitOfWorkManager.Begin())
{
var organizationUnit = await OrganizationUnitRepository.GetAsync(id);
if (organizationUnit.ParentId == parentId)
{
await uow.CompleteAsync();
return;
}
//Should find children before Code change
var children = await FindChildrenAsync(id, true);
//Store old code of OU
var oldCode = organizationUnit.Code;
//Move OU
organizationUnit.Code = await GetNextChildCodeAsync(parentId);
organizationUnit.ParentId = parentId;
await ValidateOrganizationUnitAsync(organizationUnit);
//Update Children Codes
foreach (var child in children)
{
child.Code = OrganizationUnit.AppendCode(organizationUnit.Code, OrganizationUnit.GetRelativeCode(child.Code, oldCode));
}
await uow.CompleteAsync();
}
}
public virtual async Task AddToOrganizationUnitAsync(Guid userId, Guid ouId)
{
await AddToOrganizationUnitAsync(
await UserRepository.GetAsync(userId, cancellationToken: CancellationToken),
await OrganizationUnitRepository.GetAsync(ouId, cancellationToken: CancellationToken)
);
}
public virtual void Move(long id, long?parentId)
{
var organizationUnit = OrganizationUnitRepository.Get(id);
if (organizationUnit.ParentId == parentId)
{
return;
}
//Should find children before Code change
var children = FindChildren(id, true);
//Store old code of OU
var oldCode = organizationUnit.Code;
//Move OU
organizationUnit.Code = GetNextChildCode(parentId);
organizationUnit.ParentId = parentId;
ValidateOrganizationUnit(organizationUnit);
//Update Children Codes
foreach (var child in children)
{
child.Code = OrganizationUnit.AppendCode(organizationUnit.Code, OrganizationUnit.GetRelativeCode(child.Code, oldCode));
}
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
OrganizationUnits = new OrganizationUnitRepository(context);
DocumentTypes = new DocumentTypeRepository(context);
Documents = new DocumentRepository(context);
}
public virtual async Task <ListResultDto <OrganizationUnitDto> > GetAllListAsync()
{
var origanizationUnits = await OrganizationUnitRepository.GetListAsync(false);
return(new ListResultDto <OrganizationUnitDto>(
ObjectMapper.Map <List <OrganizationUnit>, List <OrganizationUnitDto> >(origanizationUnits)));
}
public virtual async Task <ListResultDto <IdentityRoleDto> > GetMemberAssignableRolesAsync(Guid id, Guid userId)
{
var ou = await OrganizationUnitRepository.GetAsync(id, false);
var availableRoles = await GetAvailableRolesAsync(ou.ParentId);
var userRoles = ObjectMapper.Map <List <IdentityRole>, List <IdentityRoleDto> >(
await UserRepository.GetRolesAsync(userId, false)
);
var assignableRoles = new List <IdentityRoleDto>();
foreach (var ur in userRoles)
{
ur.IsStatic = true;
assignableRoles.Add(ur);
}
foreach (var avr in availableRoles)
{
if (!assignableRoles.Any(asr => asr.Id == avr.Id))
{
assignableRoles.Add(avr);
}
}
return(new ListResultDto <IdentityRoleDto>(assignableRoles));
}
public virtual async Task MoveAsync(Guid id, OrganizationUnitMoveInput input)
{
var ou = await OrganizationUnitRepository.GetAsync(id, false);
await AuthorizationService.CheckAsync(ou, CommonOperations.Update);
if (input.ParentId != ou.ParentId)
{
if (input.ParentId.HasValue)
{
var parentOrganizationUnit = await OrganizationUnitRepository.GetAsync(input.ParentId.Value, false);
await AuthorizationService.CheckAsync(parentOrganizationUnit, CommonOperations.Create);
}
else
{
await AuthorizationService.CheckAsync(null, CommonOperations.Create);
}
}
await OrganizationUnitManager.MoveAsync(ou.Id, input.ParentId);
var children = await OrganizationUnitRepository.GetChildrenAsync(input.ParentId, false);
await UpdatePositionAsync(ou, children, input.BeforeOrganizationUnitId);
}
public virtual async Task <OrganizationUnitDto> UpdateAsync(Guid id, OrganizationUnitUpdateDto input)
{
var ou = await OrganizationUnitRepository.GetAsync(id, true);
await AuthorizationService.CheckAsync(ou, CommonOperations.Update);
ou.DisplayName = input.DisplayName;
ou.ConcurrencyStamp = input.ConcurrencyStamp;
ou.SetProperty(OrganizationUnitExtraPropertyNames.IsActiveName, input.IsActive);
foreach (var roleId in ou.Roles.Select(our => our.RoleId).Except(input.RoleIds))
{
ou.RemoveRole(roleId);
}
foreach (var roleId in input.RoleIds.Except(ou.Roles.Select(our => our.RoleId)))
{
ou.AddRole(roleId);
}
await OrganizationUnitManager.UpdateAsync(ou);
//remove cache
await CacheOrganizationUnits.RemoveAsync(AllOrganizationUnitsListCacheName);
return(ObjectMapper.Map <OrganizationUnit, OrganizationUnitDto>(ou));
}
public virtual async Task MoveAsync(Guid id, Guid?parentId)
{
var organizationUnit = await OrganizationUnitRepository.GetAsync(id);
if (organizationUnit.ParentId == parentId)
{
return;
}
//Should find children before Code change
var children = await FindChildrenAsync(id, true);
//Store old code of OU
var oldCode = organizationUnit.Code;
//Move OU
organizationUnit.Code = await GetNextChildCodeAsync(parentId);
organizationUnit.ParentId = parentId;
await ValidateOrganizationUnitAsync(organizationUnit);
//Update Children Codes
foreach (var child in children)
{
child.Code = OrganizationUnit.AppendCode(organizationUnit.Code, OrganizationUnit.GetRelativeCode(child.Code, oldCode));
}
}
public virtual async Task <ListResultDto <OrganizationUnitDto> > GetAuthorizedAsync()
{
List <OrganizationUnit> list;
if (await AuthorizationService.IsGrantedAsync(OrganizationUnitPermissions.OrganizationUnits.SuperAuthorization))
{
list = await OrganizationUnitRepository.GetChildrenAsync(null, includeDetails : false);
}
else
{
list = await UserRepository.GetOrganizationUnitsAsync(CurrentUser.Id.Value, false);
list = list.Where(ou => !list.Any(y => ou.Code.StartsWith(y.Code) && y.Id != ou.Id))
.ToList();
}
var dtoList = ObjectMapper.Map <List <OrganizationUnit>, List <OrganizationUnitDto> >(list);
foreach (var dto in dtoList)
{
dto.ChildrenCount = (await OrganizationUnitRepository.GetChildrenAsync(dto.Id, false)).Count;
}
return(new ListResultDto <OrganizationUnitDto>(
dtoList.OrderBy(ou => ou.Code)
.ToList()
));
}
public virtual async Task RemoveRoleFromOrganizationUnitAsync(Guid roleId, Guid ouId)
{
await RemoveRoleFromOrganizationUnitAsync(
await IdentityRoleRepository.GetAsync(roleId),
await OrganizationUnitRepository.GetAsync(ouId, true)
);
}
public virtual async Task <OrganizationUnit> GetLastChildOrNullAsync(long?parentId)
{
var query = OrganizationUnitRepository.GetAll()
.Where(ou => ou.ParentId == parentId)
.OrderByDescending(ou => ou.Code);
return(await AsyncQueryableExecuter.FirstOrDefaultAsync(query));
}
public virtual async Task DeleteAsync(Guid id)
{
var ou = await OrganizationUnitRepository.GetAsync(id, false);
await AuthorizationService.CheckAsync(ou, CommonOperations.Delete);
await OrganizationUnitManager.DeleteAsync(ou.Id);
}
public virtual OrganizationUnit GetLastChildOrNull(long?parentId)
{
var query = OrganizationUnitRepository.GetAll()
.Where(ou => ou.ParentId == parentId)
.OrderByDescending(ou => ou.Code);
return(query.FirstOrDefault());
}
public virtual async Task <ListResultDto <IdentityRoleDto> > GetRolesAsync(Guid id)
{
var ou = await OrganizationUnitRepository.GetAsync(id, false);
return(new ListResultDto <IdentityRoleDto>(
ObjectMapper.Map <List <IdentityRole>, List <IdentityRoleDto> >(
await OrganizationUnitRepository.GetRolesAsync(ou)
)));
}
public virtual async Task <List <OrganizationUnit> > GetOrganizationUnitsAsync(IdentityUser user)
{
await IdentityUserRepository.EnsureCollectionLoadedAsync(user, u => u.OrganizationUnits, CancellationTokenProvider.Token);
return(await OrganizationUnitRepository.GetListAsync(
user.OrganizationUnits.Select(t => t.OrganizationUnitId),
cancellationToken : CancellationToken
));
}
//[Authorize(OrganizationUnitPermissions.OrganizationUnitLookup.Default)]
public virtual async Task <OrganizationUnitDto> GetAsync(Guid id)
{
var dto = ObjectMapper.Map <OrganizationUnit, OrganizationUnitDto>(
await OrganizationUnitRepository.GetAsync(id, false)
);
dto.ChildrenCount = (await OrganizationUnitRepository.GetChildrenAsync(dto.Id, false)).Count;
return(dto);
}
public virtual async Task <ListResultDto <IdentityUserDto> > GetUsersAsync(OrganizationUnitGetUserDto input)
{
var origanizationUnit = await OrganizationUnitRepository.GetAsync(input.Id);
// TODO: 官方库没有定义分页查询API，有可能是企业付费版本，需要自行实现
var origanizationUnitUsers = await UserRepository.GetUsersInOrganizationUnitAsync(origanizationUnit.Id);
return(new ListResultDto <IdentityUserDto>(
ObjectMapper.Map <List <IdentityUser>, List <IdentityUserDto> >(origanizationUnitUsers)));
}
public virtual async Task <PagedResultDto <OrganizationUnitDto> > GetListAsync(OrganizationUnitGetByPagedDto input)
{
var origanizationUnitCount = await OrganizationUnitRepository.GetCountAsync();
var origanizationUnits = await OrganizationUnitRepository
.GetListAsync(input.Sorting, input.MaxResultCount, input.SkipCount, false);
return(new PagedResultDto <OrganizationUnitDto>(origanizationUnitCount,
ObjectMapper.Map <List <OrganizationUnit>, List <OrganizationUnitDto> >(origanizationUnits)));
}
public virtual async Task DeleteAsync(Guid id)
{
var origanizationUnit = await OrganizationUnitRepository.FindAsync(id);
if (origanizationUnit == null)
{
return;
}
await OrganizationUnitManager.DeleteAsync(id);
}
public virtual Task AddRoleToOrganizationUnitAsync(IdentityRole role, OrganizationUnit ou)
{
var currentRoles = ou.Roles;
if (currentRoles.Any(r => r.OrganizationUnitId == ou.Id && r.RoleId == role.Id))
{
return(Task.FromResult(0));
}
ou.AddRole(role.Id);
return(OrganizationUnitRepository.UpdateAsync(ou));
}
public virtual void Create(OrganizationUnit organizationUnit)
{
using (var uow = UnitOfWorkManager.Begin())
{
organizationUnit.Code = GetNextChildCode(organizationUnit.ParentId);
ValidateOrganizationUnit(organizationUnit);
OrganizationUnitRepository.Insert(organizationUnit);
uow.Complete();
}
}
public virtual void Delete(long id)
{
var children = FindChildren(id, true);
foreach (var child in children)
{
OrganizationUnitRepository.Delete(child);
}
OrganizationUnitRepository.Delete(id);
}
public virtual async Task DeleteAsync(long id)
{
var children = await FindChildrenAsync(id, true);
foreach (var child in children)
{
await OrganizationUnitRepository.DeleteAsync(child);
}
await OrganizationUnitRepository.DeleteAsync(id);
}
public async Task Should_Lazy_Load_OrganizationUnit_Collections()
{
using (var uow = GetRequiredService <IUnitOfWorkManager>().Begin())
{
var ou = await OrganizationUnitRepository.GetAsync(LookupNormalizer.NormalizeName("OU111"), includeDetails : false);
ou.Roles.ShouldNotBeNull(); //?
ou.Roles.Any().ShouldBeTrue();
await uow.CompleteAsync();
}
}
public virtual async Task RemoveRoleAsync(OrganizationUnitDtoAddOrRemoveRoleDto input)
{
var origanizationUnit = await OrganizationUnitRepository.GetAsync(input.Id);
if (origanizationUnit.IsInRole(input.RoleId))
{
origanizationUnit.RemoveRole(input.RoleId);
await OrganizationUnitManager.UpdateAsync(origanizationUnit);
await CurrentUnitOfWork.SaveChangesAsync();
}
}
public virtual async Task <GetOrganizationUnitForEditOutput> GetOrganizationUnitForEditAsync(Guid id)
{
var ou = await OrganizationUnitRepository.GetAsync(id, true);
var output = new GetOrganizationUnitForEditOutput();
output.OrganizationUnit = ObjectMapper.Map <OrganizationUnit, OrganizationUnitEditDto>(ou);
output.RoleIds = ou.Roles.Select(r => r.RoleId).ToArray();
output.AvailableRoles = await GetAvailableRolesAsync(ou.ParentId);
return(output);
}
public virtual async Task <PagedResultDto <IdentityUserDto> > GetMembersAsync(Guid id, GetOrganizationUnitMembersInput input)
{
var ou = await OrganizationUnitRepository.GetAsync(id, false);
var count = await OrganizationUnitRepository.GetMembersCountAsync(ou, input.Filter);
var members = await OrganizationUnitRepository.GetMembersAsync(ou, input.Sorting, input.MaxResultCount, input.SkipCount, input.Filter);
return(new PagedResultDto <IdentityUserDto>(count,
ObjectMapper.Map <List <IdentityUser>, List <IdentityUserDto> >(members)
));
}
public virtual async Task <PagedResultDto <IdentityRoleDto> > GetRolesAsync(OrganizationUnitGetRoleByPagedDto input)
{
var origanizationUnit = await OrganizationUnitRepository.GetAsync(input.Id);
var origanizationUnitRoleCount = await OrganizationUnitRepository.GetRolesCountAsync(origanizationUnit);
var origanizationUnitRoles = await OrganizationUnitRepository.GetRolesAsync(origanizationUnit,
input.Sorting, input.MaxResultCount, input.SkipCount, false);
return(new PagedResultDto <IdentityRoleDto>(origanizationUnitRoleCount,
ObjectMapper.Map <List <IdentityRole>, List <IdentityRoleDto> >(origanizationUnitRoles)));
}
