public async Task DeleteUserAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);
var localizerIdentityResource = new IdentityServiceResources();
IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);
//Generate random new user
var userDto = IdentityDtoMock.GenerateRandomUser(Guid.NewGuid());
await identityService.CreateUserAsync(userDto);
//Get new user
var user = await context.Users.Where(x => x.UserName == userDto.UserName).SingleOrDefaultAsync();
userDto.Id = user.Id;
var newUserDto = await identityService.GetUserAsync(userDto);
//Assert new user
userDto.ShouldBeEquivalentTo(newUserDto);
//Remove user
await identityService.DeleteUserAsync(newUserDto);
//Try Get Removed user
var removeUser = await context.Users.Where(x => x.Id == user.Id)
.SingleOrDefaultAsync();
//Assert removed user
removeUser.Should().BeNull();
}
}
public async Task DeleteRoleAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
var testUserManager = GetTestUserManager(context);
var testRoleManager = GetTestRoleManager(context);
IIdentityRepository identityRepository = new IdentityRepository(context, testUserManager, testRoleManager);
var localizerIdentityResource = new IdentityServiceResources();
IIdentityService identityService = new IdentityService(identityRepository, localizerIdentityResource);
//Generate random new role
var roleDto = IdentityDtoMock.GenerateRandomRole(0);
await identityService.CreateRoleAsync(roleDto);
//Get new role
var role = await context.Roles.Where(x => x.Name == roleDto.Name).SingleOrDefaultAsync();
roleDto.Id = role.Id;
var newRoleDto = await identityService.GetRoleAsync(roleDto);
//Assert new role
roleDto.ShouldBeEquivalentTo(newRoleDto);
//Remove role
await identityService.DeleteRoleAsync(newRoleDto);
//Try Get Removed role
var removeRole = await context.Roles.Where(x => x.Id == role.Id)
.SingleOrDefaultAsync();
//Assert removed role
removeRole.Should().BeNull();
}
}
public ActionResult AdminLogin(AdminLogin aLogin)
{
if (ModelState.IsValid)
{
var context = new AdminDbContext();
var retrive = context.Admin.Where(n => n.AdminID == aLogin.AdminID);
foreach (var i in retrive)
{
if (i.isApproved == false)
{
TempData["superRoot"] = "SuperUser approval is needed";
return(View(aLogin));
}
if (i.AdminID == (aLogin.AdminID) && i.Password == aLogin.Password && i.isApproved == true)
{
FormsAuthentication.SetAuthCookie(aLogin.AdminID, false);
return(RedirectToAction("Index"));
}
}
}
TempData["adminLogin"] = "******";
return(View(aLogin));
}
/// <summary>
/// Generate default clients, identity and api resources
/// </summary>
private static async Task EnsureSeedIdentityServerData(AdminDbContext context)
{
if (!context.Clients.Any())
{
foreach (var client in Clients.GetAdminClient().ToList())
{
var clientDb = client.ToEntity();
await context.Clients.AddAsync(clientDb);
}
await context.SaveChangesAsync();
}
if (!context.IdentityResources.Any())
{
var identityResources = ClientResources.GetIdentityResources().ToList();
foreach (var resource in identityResources)
{
await context.IdentityResources.AddAsync(resource.ToEntity());
}
await context.SaveChangesAsync();
}
if (!context.ApiResources.Any())
{
foreach (var resource in ClientResources.GetApiResources().ToList())
{
await context.ApiResources.AddAsync(resource.ToEntity());
}
await context.SaveChangesAsync();
}
}
public async Task DeletePersistedGrantAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
var persistedGrantRepository = new PersistedGrantRepository(context);
//Generate persisted grant
var persistedGrantKey = Guid.NewGuid().ToString();
var persistedGrant = PersistedGrantMock.GenerateRandomPersistedGrant(persistedGrantKey);
//Try add new persisted grant
await context.PersistedGrants.AddAsync(persistedGrant);
await context.SaveChangesAsync();
//Try delete persisted grant
await persistedGrantRepository.DeletePersistedGrantAsync(persistedGrantKey);
var grant = await persistedGrantRepository.GetPersitedGrantAsync(persistedGrantKey);
//Assert
grant.Should().BeNull();
}
}
public async Task CloneClientWithoutScopesAsync()
{
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
//Generate random new client
var client = ClientMock.GenerateRandomClient(0, generateClaims: true, generateProperties: true, generateSecrets: true);
IClientRepository clientRepository = new ClientRepository(context);
//Add new client
await clientRepository.AddClientAsync(client);
var clientToClone = await context.Clients.Where(x => x.Id == client.Id).SingleOrDefaultAsync();
//Try clone it
var clonedClientId = await clientRepository.CloneClientAsync(clientToClone, cloneClientScopes : false);
var cloneClientEntity = await clientRepository.GetClientAsync(clonedClientId);
var clientToCompare = await clientRepository.GetClientAsync(clientToClone.Id);
ClientCloneCompare(cloneClientEntity, clientToCompare, cloneClientScopes: false);
}
}
public DefaultSettingsCreator(AdminDbContext context)
{
_context = context;
}
internal static IEnumerable <HomePageRelationTypeDisplayModel> GetHomeRelationTypes(AdminDbContext context = null)
{
context = context ?? new AdminDbContext();
return(context.RelationTypes.OrderBy(rt => rt.Name).Where(rt => rt.Relations.Any()).Select(rt => new HomePageRelationTypeDisplayModel()
{
Id = rt.Id, Name = rt.Name, Count = rt.Relations.Count()
}));
}
public UsuariosController(AdminDbContext context)
{
_context = context;
}
public SystemService(IConfigRepository configRepository, ICacheHandler cache, AdminDbContext dbContext)
{
_configRepository = configRepository;
_cache = cache;
_dbContext = dbContext;
}
public AdminRL(AdminDbContext adminContext)
{
this.adminContext = adminContext;
}
public DanhMucDAO()
{
context = new AdminDbContext();
}
public DefaultLanguagesCreator(AdminDbContext context)
{
_context = context;
}
public MetaValuesServiceBase(AdminDbContext context) : base(context)
{
}
public PromoPageController(AdminDbContext db)
{
_db = db;
}
private IClientRepository <AdminDbContext> GetClientRepository(AdminDbContext context)
{
IClientRepository <AdminDbContext> clientRepository = new ClientRepository <AdminDbContext>(context);
return(clientRepository);
}
public InitialHostDbBuilder(AdminDbContext context)
{
_context = context;
}
public AccountService(ICacheHandler cache, IMapper mapper, IAccountRepository accountRepository, IAccountRoleRepository accountRoleRepository, IMenuRepository menuRepository, IRoleRepository roleRepository, IButtonRepository buttonRepository, IPermissionRepository permissionRepository, DrawingHelper drawingHelper, ISystemService systemService, IServiceProvider serviceProvider, IAccountConfigRepository accountConfigRepository, AdminDbContext dbContext, SystemConfigModel systemConfig)
{
_cache = cache;
_mapper = mapper;
_accountRepository = accountRepository;
_accountRoleRepository = accountRoleRepository;
_menuRepository = menuRepository;
_roleRepository = roleRepository;
_buttonRepository = buttonRepository;
_permissionRepository = permissionRepository;
_drawingHelper = drawingHelper;
_systemService = systemService;
_serviceProvider = serviceProvider;
_accountConfigRepository = accountConfigRepository;
_dbContext = dbContext;
_systemConfig = systemConfig;
}
public ClientRepository(AdminDbContext dbContext)
{
_dbContext = dbContext;
}
public EmployeeService(IMapper mapper, IEmployeeRepository repository, IAccountService accountService, IAccountRepository accountRepository, IEmployeeContactRepository contactRepository, AdminDbContext adminDbContext, PersonnelFilesDbContext dbContext, IEmployeeLeaveInfoRepository leaveInfoRepository, IEmployeePersonalRepository personalRepository, IEmployeeFamilyRepository familyRepository, IEmployeeEducationRepository educationRepository, IEmployeeWorkRepository workRepository, IEmployeeLatestSelectRepository latestSelectRepository, ICacheHandler cacheHandler, IDepartmentRepository departmentRepository, IAccountRoleRepository accountRoleRepository, IConfigProvider configProvider)
{
_mapper = mapper;
_repository = repository;
_accountService = accountService;
_accountRepository = accountRepository;
_contactRepository = contactRepository;
_adminDbContext = adminDbContext;
_dbContext = dbContext;
_leaveInfoRepository = leaveInfoRepository;
_personalRepository = personalRepository;
_familyRepository = familyRepository;
_educationRepository = educationRepository;
_workRepository = workRepository;
_latestSelectRepository = latestSelectRepository;
_cacheHandler = cacheHandler;
_departmentRepository = departmentRepository;
_accountRoleRepository = accountRoleRepository;
_configProvider = configProvider;
}
public async Task CloneClientAsync()
{
int clonedClientId;
using (var context = new AdminDbContext(_dbContextOptions, _storeOptions, _operationalStore))
{
//Generate random new client
var clientDto = ClientDtoMock.GenerateRandomClient(0);
var clientRepository = GetClientRepository(context);
var localizerMock = new Mock <IClientServiceResources>();
var localizer = localizerMock.Object;
var clientService = GetClientService(clientRepository, localizer);
//Add new client
await clientService.AddClientAsync(clientDto);
var clientId = await context.Clients.Where(x => x.ClientId == clientDto.ClientId).Select(x => x.Id)
.SingleOrDefaultAsync();
var clientDtoToClone = await clientService.GetClientAsync(clientId);
var clientCloneDto = ClientDtoMock.GenerateClientCloneDto(clientDtoToClone.Id);
//Try clone it
clonedClientId = await clientService.CloneClientAsync(clientCloneDto);
var cloneClientEntity = await context.Clients
.Include(x => x.AllowedGrantTypes)
.Include(x => x.RedirectUris)
.Include(x => x.PostLogoutRedirectUris)
.Include(x => x.AllowedScopes)
.Include(x => x.ClientSecrets)
.Include(x => x.Claims)
.Include(x => x.IdentityProviderRestrictions)
.Include(x => x.AllowedCorsOrigins)
.Include(x => x.Properties)
.Where(x => x.Id == clonedClientId).SingleOrDefaultAsync();
var clientToCompare = await context.Clients
.Include(x => x.AllowedGrantTypes)
.Include(x => x.RedirectUris)
.Include(x => x.PostLogoutRedirectUris)
.Include(x => x.AllowedScopes)
.Include(x => x.ClientSecrets)
.Include(x => x.Claims)
.Include(x => x.IdentityProviderRestrictions)
.Include(x => x.AllowedCorsOrigins)
.Include(x => x.Properties)
.Where(x => x.Id == clientDtoToClone.Id).SingleOrDefaultAsync();
//Assert cloned client
cloneClientEntity.ShouldBeEquivalentTo(clientToCompare,
options => options.Excluding(o => o.Id)
.Excluding(o => o.ClientSecrets)
.Excluding(o => o.ClientId)
.Excluding(o => o.ClientName)
//Skip the collections because is not possible ignore property in list :-(
//Note: I've found the solution above - try ignore property of the list using SelectedMemberPath
.Excluding(o => o.AllowedGrantTypes)
.Excluding(o => o.RedirectUris)
.Excluding(o => o.PostLogoutRedirectUris)
.Excluding(o => o.AllowedScopes)
.Excluding(o => o.ClientSecrets)
.Excluding(o => o.Claims)
.Excluding(o => o.IdentityProviderRestrictions)
.Excluding(o => o.AllowedCorsOrigins)
.Excluding(o => o.Properties)
);
//New client relations have new id's and client relations therefore is required ignore them
cloneClientEntity.AllowedGrantTypes.ShouldBeEquivalentTo(clientToCompare.AllowedGrantTypes,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.AllowedCorsOrigins.ShouldBeEquivalentTo(clientToCompare.AllowedCorsOrigins,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.RedirectUris.ShouldBeEquivalentTo(clientToCompare.RedirectUris,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.PostLogoutRedirectUris.ShouldBeEquivalentTo(clientToCompare.PostLogoutRedirectUris,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.AllowedScopes.ShouldBeEquivalentTo(clientToCompare.AllowedScopes,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.ClientSecrets.ShouldBeEquivalentTo(clientToCompare.ClientSecrets,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.Claims.ShouldBeEquivalentTo(clientToCompare.Claims,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.IdentityProviderRestrictions.ShouldBeEquivalentTo(
clientToCompare.IdentityProviderRestrictions,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
cloneClientEntity.Properties.ShouldBeEquivalentTo(clientToCompare.Properties,
option => option.Excluding(x => x.SelectedMemberPath.EndsWith("Id"))
.Excluding(x => x.SelectedMemberPath.EndsWith("Client")));
}
}
public MenuController(AdminDbContext adminDbContext)
{
AdminDbContext = adminDbContext;
}
public AccountService(ICacheHandler cache, IMapper mapper, IAccountRepository accountRepository, IAccountRoleRepository accountRoleRepository, IRoleRepository roleRepository, IPermissionRepository permissionRepository, IAccountConfigRepository accountConfigRepository, AdminDbContext dbContext, IPasswordHandler passwordHandler, IConfigProvider configProvider)
{
_cache = cache;
_mapper = mapper;
_accountRepository = accountRepository;
_accountRoleRepository = accountRoleRepository;
_roleRepository = roleRepository;
_permissionRepository = permissionRepository;
_accountConfigRepository = accountConfigRepository;
_dbContext = dbContext;
_passwordHandler = passwordHandler;
_configProvider = configProvider;
}
public MenuRepository(AdminDbContext dbcontext) : base(dbcontext)
{
}
public AuthService(DrawingHelper drawingHelper, ICacheHandler cacheHandler, SystemConfigModel systemConfig, IAccountRepository accountRepository, AdminDbContext dbContext, IAccountAuthInfoRepository authInfoRepository, IPasswordHandler passwordHandler, IAccountConfigRepository configRepository, IServiceProvider serviceProvider, IMenuRepository menuRepository, IMapper mapper, IButtonRepository buttonRepository, ILoginInfo loginInfo, AdminOptions options)
{
_drawingHelper = drawingHelper;
_cacheHandler = cacheHandler;
_systemConfig = systemConfig;
_accountRepository = accountRepository;
_dbContext = dbContext;
_authInfoRepository = authInfoRepository;
_passwordHandler = passwordHandler;
_configRepository = configRepository;
_serviceProvider = serviceProvider;
_menuRepository = menuRepository;
_mapper = mapper;
_buttonRepository = buttonRepository;
_loginInfo = loginInfo;
_options = options;
}
private UserManager <UserIdentity> GetTestUserManager(AdminDbContext context)
{
var testUserManager = IdentityMock.TestUserManager(new UserStore <UserIdentity, UserIdentityRole, AdminDbContext, Guid, UserIdentityUserClaim, UserIdentityUserRole, UserIdentityUserLogin, UserIdentityUserToken, UserIdentityRoleClaim>(context, new IdentityErrorDescriber()));
return(testUserManager);
}
public InvoiceController(AdminDbContext context)
{
_context = context;
}
private RoleManager <UserIdentityRole> GetTestRoleManager(AdminDbContext context)
{
var testRoleManager = IdentityMock.TestRoleManager(new RoleStore <UserIdentityRole, AdminDbContext, Guid, UserIdentityUserRole, UserIdentityRoleClaim>(context, new IdentityErrorDescriber()));
return(testRoleManager);
}
/// <summary>
/// Create a <seealso cref="BaseController">BaseController</seealso> with <b>no</b> default bundles
/// </summary>
public BaseController(MainDbContext mainContext, AdminDbContext adminContext)
: this(mainContext, adminContext, null, null)
{
}
public TenantRoleAndUserBuilder(AdminDbContext context, int tenantId)
{
_context = context;
_tenantId = tenantId;
}
