public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
//Getting all available roles
var output = new GetUserForEditOutput();
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
output.MemberedOrganizationUnits = new List <long>();
output.Roles = new List <string>();
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = ObjectMapper.Map <UserEditDto>(user);
output.ProfilePictureId = user.ProfilePictureId;
output.Roles = await UserManager.GetRolesAsync(user);
var organizationUnits = await UserManager.GetOrganizationUnitsAsync(user);
output.MemberedOrganizationUnits = organizationUnits.Select(ou => ou.Id).ToList();
}
return(output);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
//Getting all available roles
var userRoleDtos = await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync();
var allOrganizationUnits = await _organizationUnitRepository.GetAllListAsync();
var output = new GetUserForEditOutput
{
Roles = userRoleDtos,
MemberedOrganizationUnits = new List <string>()
};
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = ObjectMapper.Map <UserEditDto>(user);
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(user, userRoleDto.RoleName);
}
var organizationUnits = await UserManager.GetOrganizationUnitsAsync(user);
output.MemberedOrganizationUnits = organizationUnits.Select(ou => ou.Code).ToList();
}
return(output);
}
public async Task <GetUserForEditOutput> GetExistUSerForActive(string civilId)
{
using (CurrentUnitOfWork.DisableFilter(AbpDataFilters.SoftDelete))
{
//Editing an existing user
var user = UserManager.Users.Where(c => c.CivilId == civilId && c.IsDeleted == true).FirstOrDefault();
//Getting all available roles
var userRoleDtos = await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync();
var allOrganizationUnits = await _organizationUnitRepository.GetAllListAsync();
var allShifts = await _shiftRepository.GetAllListAsync();
var output = new GetUserForEditOutput
{
Roles = userRoleDtos,
AllOrganizationUnits = ObjectMapper.Map <List <OrganizationUnitDto> >(allOrganizationUnits),
MemberedOrganizationUnits = new List <string>(),
MemberOrganizationUnit = "",
Shifts = ObjectMapper.Map <List <ShiftDto> >(allShifts)
};
if (user != null)
{
output.User = ObjectMapper.Map <UserEditDto>(user);
var timeProfile = _timeProfileRepository.GetAll().Where(x => x.UserId == output.User.Id).FirstOrDefault();
output.ProfilePictureId = user.ProfilePictureId;
var organizationUnits = await UserManager.GetOrganizationUnitsAsync(user);
output.MemberedOrganizationUnits = organizationUnits.Select(ou => ou.Code).ToList();
output.MemberOrganizationUnit = allOrganizationUnits.Where(ou => ou.Id == user.OrganizationUnitId).Select(ou => ou.Code).FirstOrDefault();
var allRolesOfUsersOrganizationUnits = GetAllRoleNamesOfUsersOrganizationUnits(user.Id);
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(user, userRoleDto.RoleName);
userRoleDto.InheritedFromOrganizationUnit = allRolesOfUsersOrganizationUnits.Contains(userRoleDto.RoleName);
}
}
return(output);
}
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
//Getting all available roles
var userRoleDtos = (await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync());
var output = new GetUserForEditOutput
{
Roles = userRoleDtos
};
if (!input.Id.HasValue)
{
bool.TryParse(await SettingManager.GetSettingValueAsync(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled), out bool isEnabled);
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
//IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync<bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
IsLockoutEnabled = isEnabled
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await _userManager.Users.FirstOrDefaultAsync(x => x.Id == input.Id.Value);
output.User = user.MapTo <UserEditDto>();
output.ProfilePictureId = user.ProfilePictureId;
output.OrganizationIds = await _organizationUnitApp.GetUserOrganizationUnits(new UserIdInput { UserId = input.Id ?? 0 });
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await _userManager.IsInRoleAsync(user, userRoleDto.RoleName);
}
}
return(output);
}
public async Task <GetUserForEditOutput> GetUserUnitForEdit(NullableIdInput <long> input)
{
//Getting all available roles
var userRoleDtos = (await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync());
var output = new GetUserForEditOutput
{
Roles = userRoleDtos
};
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto {
IsActive = true, ShouldChangePasswordOnNextLogin = true
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = user.MapTo <UserEditDto>();
output.ProfilePictureId = user.ProfilePictureId;
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(input.Id.Value, userRoleDto.RoleName);
}
if (!ReferenceEquals(AbpSession.TenantId, null))
{
output.TenantwithRoles = await GetTenantListofOrganizationforEdit(user.UserName);
}
}
return(output);
}
public async Task <GetUserForEditOutput> GetForEditAsync(NullableIdDto <long> input)
{
var userRoleDtos = await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync();
var output = new GetUserForEditOutput()
{
Roles = userRoleDtos
};
if (input.Id.HasValue)
{ //修改
User user = await _userRepository.GetAsync(input.Id.Value);
if (user == null)
{
throw new UserFriendlyException("用户不存在");
}
output.User = _mapper.Map <UserEditDto>(user);
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(user, userRoleDto.RoleName);
}
}
else
{
output.User = new UserEditDto()
{
IsActive = true,
//ShouldChangePasswordOnNextLogin = true,
//IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync<bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
//IsLockoutEnabled = await SettingManager.GetSettingValueAsync<bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
return(output);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
var userRoleDtos = (await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto()
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync());
var output = new GetUserForEditOutput
{
Roles = userRoleDtos
};
if (!input.Id.HasValue)
{
//create
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//edit
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = user.MapTo <UserEditDto>();
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(user.Id, userRoleDto.RoleName);
}
}
return(output);
}
/// <summary>
/// 获取用户用于编辑
/// </summary>
/// <param name="input"></param>
/// <returns></returns>
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
//Getting all available roles
var userRoleDtos = (await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync());
var output = new GetUserForEditOutput
{
Roles = userRoleDtos
};
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = user.MapTo <UserEditDto>();
output.ProfilePictureId = user.ProfilePictureId;
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(input.Id.Value, userRoleDto.RoleName);
}
}
return(output);
}
public async Task <GetUserForEditOutput> GetForEdit(GetForEditInput input)
{
var listRoleLevelEnum = GetROLE_LEVELs(input.LoaiTaiKhoan);
var userRoleDtos = (await _roleManager.Roles
.Where(x => listRoleLevelEnum.Contains(x.RoleLevel.Value))
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName,
RoleLevel = r.RoleLevel
})
.ToArrayAsync());
var output = new GetUserForEditOutput
{
Roles = userRoleDtos
};
if (input.Id.HasValue)
{
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = user.MapTo <UserEditDto>();
output.ProfilePictureId = user.ProfilePictureId;
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(input.Id.Value, userRoleDto.RoleName);
}
}
else
{
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = false,
IsTwoFactorEnabled = false,
IsLockoutEnabled = true
};
}
return(output);
}
/// <summary>
/// 获取编辑页面的用户信息
/// </summary>
/// <param name="id">用户Id</param>
/// <returns>获取编辑页面的用户信息 输出模型</returns>
public async Task <GetUserForEditOutput> GetUserForEdit(long id)
{
GetUserForEditOutput output = new GetUserForEditOutput();
output.User = await UserManager.GetUserByIdAsync(id);
var roleStrings = await UserManager.GetRolesAsync(id);
var rolesList = new List <Role>();
foreach (var roleId in roleStrings)
{
var role = await _roleManager.GetRoleByIdAsync(Convert.ToInt32(roleId));
rolesList.Add(role);
}
output.Roles = rolesList;
return(output);
}
/// <summary>
/// 通过Id获取用户信息进行编辑或修改
/// </summary>
public async Task <GetUserForEditOutput> GetUserForEditAsync(NullableIdDto <Guid> input)
{
var output = new GetUserForEditOutput();
UserEditDto userEditDto;
if (input.Id.HasValue)
{
var entity = await _userRepository.GetAsync(input.Id.Value);
userEditDto = entity.MapTo <UserEditDto>();
}
else
{
userEditDto = new UserEditDto();
}
output.User = userEditDto;
return(output);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
var output = new GetUserForEditOutput
{
Roles = new List <AssignedUserRoleDto>()
};
if (!input.Id.HasValue)
{
var defaultRoles = await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync();
//Creating a new user
output.Item = new UserEditDto
{
IsActive = true,
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
output.Roles = ObjectMapper.Map <List <AssignedUserRoleDto> >(defaultRoles);
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.Item = ObjectMapper.Map <UserEditDto>(user);
var userRoleDtos = await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.ToListAsync();
foreach (var userRoleDto in userRoleDtos)
{
if (await UserManager.IsInRoleAsync(user, userRoleDto.Name))
{
output.Roles.Add(ObjectMapper.Map <AssignedUserRoleDto>(userRoleDto));
}
}
}
return(output);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
var output = new GetUserForEditOutput();
if (!input.Id.HasValue)
{
//Creating a new user
output = new GetUserForEditOutput
{
IsActive = true,
ShouldChangePasswordOnNextLogin = false
};
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output = user.MapTo <GetUserForEditOutput>();
}
return(output);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
var tenantInfo = await TenantManager.GetTenantInfo();
var userId = _userManager.AbpSession.GetUserId();
var currentUser = await _userManager.GetUserByIdAsync(userId);
var currentUserRoles = await _userManager.GetRolesAsync(currentUser);
var bestRole = GetBestRole((List <string>)currentUserRoles, tenantInfo.Tenant.TenantType);
var availableRoles = GetAvailableRoles(bestRole, tenantInfo.Tenant.TenantType);
//Getting all roles that the current user is auhorized to assign
UserRoleDto[] userRoleDtos = await _roleManager.Roles
.Where(r => availableRoles.Contains(r.Name))
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync();
var allOrganizationUnits = await _organizationUnitRepository.GetAllListAsync();
var output = new GetUserForEditOutput
{
Roles = userRoleDtos,
AllOrganizationUnits = ObjectMapper.Map <List <OrganizationUnitDto> >(allOrganizationUnits),
MemberedOrganizationUnits = new List <string>()
};
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = ObjectMapper.Map <UserEditDto>(user);
output.ProfilePictureId = user.ProfilePictureId;
var organizationUnits = await UserManager.GetOrganizationUnitsAsync(user);
output.MemberedOrganizationUnits = organizationUnits.Select(ou => ou.Code).ToList();
var allRolesOfUsersOrganizationUnits = GetAllRoleNamesOfUsersOrganizationUnits(input.Id.Value);
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(user, userRoleDto.RoleName);
userRoleDto.InheritedFromOrganizationUnit = allRolesOfUsersOrganizationUnits.Contains(userRoleDto.RoleName);
}
}
return(output);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
//Getting all available roles
var userRoleDtos = await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync();
//Getting all available Locations
var userLocationDtos = await _locationRepository.GetAll()
.OrderBy(r => r.TitleAr)
.Select(r => new UserLocationDto
{
LocationId = r.Id,
LocationDisplayName = r.TitleAr,
})
.ToArrayAsync();
var allOrganizationUnits = await _organizationUnitRepository.GetAllListAsync();
var nationalities = await _nationalityRepository.GetAllListAsync();
var allBeacons = await _beaconRepository.GetAllListAsync();
//user shifts
var output = new GetUserForEditOutput
{
Locations = userLocationDtos,
Nationalities = ObjectMapper.Map <List <NationalityDto> >(nationalities),
Roles = userRoleDtos,
AllOrganizationUnits = ObjectMapper.Map <List <OrganizationUnitDto> >(allOrganizationUnits),
AllBeacons = ObjectMapper.Map <List <BeaconDto> >(allBeacons),
MemberedOrganizationUnits = new List <string>(),
MemberOrganizationUnit = ""
};
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await UserManager.Users.Include(x => x.Locations).FirstOrDefaultAsync(x => x.Id == input.Id.Value);
output.User = ObjectMapper.Map <UserEditDto>(user);
var userShifts = from o in _userShiftRepository.GetAll()
join o2 in _shiftRepository.GetAll() on o.ShiftId equals o2.Id into j2
from s2 in j2.DefaultIfEmpty()
where o.UserId == input.Id
select new GetUserShiftForViewDto()
{
UserShift = new UserShiftDto
{
Date = o.Date,
Id = o.Id,
UserId = o.UserId,
ShiftId = o.ShiftId
},
ShiftNameEn = s2 == null ? "" : s2.NameEn.ToString()
};
output.User.UserShifts = await userShifts.ToListAsync();
output.ProfilePictureId = user.ProfilePictureId;
var organizationUnits = await UserManager.GetOrganizationUnitsAsync(user);
output.MemberedOrganizationUnits = organizationUnits.Select(ou => ou.Code).ToList();
output.MemberOrganizationUnit = allOrganizationUnits.Where(ou => ou.Id == user.OrganizationUnitId).Select(ou => ou.Code).FirstOrDefault();
var allRolesOfUsersOrganizationUnits = GetAllRoleNamesOfUsersOrganizationUnits(input.Id.Value);
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(user, userRoleDto.RoleName);
userRoleDto.InheritedFromOrganizationUnit = allRolesOfUsersOrganizationUnits.Contains(userRoleDto.RoleName);
}
foreach (var userLocationDto in userLocationDtos)
{
userLocationDto.IsAssigned = user.Locations.Any(x => x.LocationId == userLocationDto.LocationId);
if (userLocationDto.IsAssigned)
{
userLocationDto.FromDate = user.Locations.Where(x => x.LocationId == userLocationDto.LocationId).FirstOrDefault().FromDate;
userLocationDto.ToDate = user.Locations.Where(x => x.LocationId == userLocationDto.LocationId).FirstOrDefault().ToDate;
}
}
}
return(output);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdInput <long> input)
{
IQueryable <Role> roles = this._roleManager.Roles;
IOrderedQueryable <Role> displayName =
from r in roles
orderby r.DisplayName
select r;
UserRoleDto[] arrayAsync = await(
from r in displayName
select new UserRoleDto()
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
}).ToArrayAsync <UserRoleDto>();
UserRoleDto[] userRoleDtoArray = arrayAsync;
GetUserForEditOutput getUserForEditOutput = new GetUserForEditOutput()
{
Roles = userRoleDtoArray
};
if (input.Id.HasValue)
{
FuelWerx.Authorization.Users.UserManager userManager = this.UserManager;
long?id = input.Id;
User userByIdAsync = await userManager.GetUserByIdAsync(id.Value);
getUserForEditOutput.User = userByIdAsync.MapTo <UserEditDto>();
getUserForEditOutput.ProfilePictureId = userByIdAsync.ProfilePictureId;
IRepository <UserSettingData, long> repository = this._userSettingDataRepository;
UserSettingData userSettingDatum = await repository.FirstOrDefaultAsync((UserSettingData m) => m.UserId == userByIdAsync.Id);
UserSettingData userSettingDatum1 = userSettingDatum;
if (userSettingDatum1 == null)
{
GetUserForEditOutput getUserForEditOutput1 = getUserForEditOutput;
UserSettingData userSettingDatum2 = new UserSettingData()
{
UserId = userByIdAsync.Id
};
getUserForEditOutput1.UserSettingData = userSettingDatum2.MapTo <UserSettingDataEditDto>();
}
else
{
getUserForEditOutput.UserSettingData = userSettingDatum1.MapTo <UserSettingDataEditDto>();
}
UserRoleDto[] userRoleDtoArray1 = userRoleDtoArray;
for (int i = 0; i < (int)userRoleDtoArray1.Length; i++)
{
UserRoleDto userRoleDto = userRoleDtoArray1[i];
UserRoleDto userRoleDto1 = userRoleDto;
FuelWerx.Authorization.Users.UserManager userManager1 = this.UserManager;
id = input.Id;
bool flag = await userManager1.IsInRoleAsync(id.Value, userRoleDto.RoleName);
userRoleDto1.IsAssigned = flag;
userRoleDto1 = null;
}
userRoleDtoArray1 = null;
}
else
{
GetUserForEditOutput getUserForEditOutput2 = getUserForEditOutput;
UserEditDto userEditDto = new UserEditDto()
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true
};
getUserForEditOutput2.User = userEditDto;
getUserForEditOutput.UserSettingData = new UserSettingDataEditDto()
{
UserId = (long)0
};
IQueryable <Role> roles1 = this._roleManager.Roles;
List <Role> listAsync = await(
from r in roles1
where r.IsDefault
select r).ToListAsync <Role>();
foreach (Role role in listAsync)
{
UserRoleDto userRoleDto2 = userRoleDtoArray.FirstOrDefault <UserRoleDto>((UserRoleDto ur) => ur.RoleName == role.Name);
if (userRoleDto2 == null)
{
continue;
}
userRoleDto2.IsAssigned = true;
}
}
return(getUserForEditOutput);
}
public async Task <GetUserForEditOutput> GetUserForEdit(NullableIdDto <long> input)
{
//Getting all available roles
var userRoleDtos = (await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName,
RoleLevel = r.RoleLevel
})
.ToArrayAsync());
var output = new GetUserForEditOutput
{
Roles = userRoleDtos
};
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
output.User = user.MapTo <UserEditDto>();
output.ProfilePictureId = user.ProfilePictureId;
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(input.Id.Value, userRoleDto.RoleName);
}
}
if (!string.IsNullOrWhiteSpace(output.User.UrlImageChuKyNhay))
{
string HCC_FILE_PDF = GetUrlFileDefaut();
var folderPath = Path.Combine(HCC_FILE_PDF, output.User.UrlImageChuKyNhay);
if (File.Exists(folderPath))
{
using (var fsTempProfilePicture = new FileStream(folderPath, FileMode.Open))
{
using (var bmpImage = new Bitmap(fsTempProfilePicture))
{
using (var stream = new MemoryStream())
{
bmpImage.Save(stream, bmpImage.RawFormat);
stream.Close();
output.User.DataImage = stream.ToArray();
}
}
}
}
}
return(output);
}
public CreateOrEditUserModalViewModel(GetUserForEditOutput output)
{
output.MapTo(this);
}
public async Task <GetUserForEditOutput> GetUserForEdit([FromQuery] NullableIdDto <long> input)
{
//Getting all available roles
var userRoleDtos = (await _roleManager.Roles
.OrderBy(r => r.DisplayName)
.Select(r => new UserRoleDto
{
RoleId = r.Id,
RoleName = r.Name,
RoleDisplayName = r.DisplayName
})
.ToArrayAsync());
var output = new GetUserForEditOutput
{
Roles = userRoleDtos
};
if (!input.Id.HasValue)
{
//Creating a new user
output.User = new UserEditDto
{
IsActive = true,
ShouldChangePasswordOnNextLogin = true,
IsTwoFactorEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.TwoFactorLogin.IsEnabled),
IsLockoutEnabled = await SettingManager.GetSettingValueAsync <bool>(AbpZeroSettingNames.UserManagement.UserLockOut.IsEnabled)
};
foreach (var defaultRole in await _roleManager.Roles.Where(r => r.IsDefault).ToListAsync())
{
var defaultUserRole = userRoleDtos.FirstOrDefault(ur => ur.RoleName == defaultRole.Name);
if (defaultUserRole != null)
{
defaultUserRole.IsAssigned = true;
}
}
}
else
{
//Editing an existing user
var user = await UserManager.GetUserByIdAsync(input.Id.Value);
var account = await _accountCache.GetAsync(user.Id);
output.User = ObjectMapper.Map <UserEditDto>(user);
output.ProfilePictureId = account.ProfilePictureId;
await UserManager.UserStore.UserRepository.EnsureCollectionLoadedAsync(user, u => u.Logins);
output.ExternalLogins = user.Logins.Select(l =>
{
return(l.MapTo <ExternalUserLoginDto>());
}).ToArray();
foreach (var userRoleDto in userRoleDtos)
{
userRoleDto.IsAssigned = await UserManager.IsInRoleAsync(user, userRoleDto.RoleName);
}
output.Permissions = await this.GetUserPermissionsForEdit(new EntityDto <long>(user.Id));
}
return(output);
}
