public AppIdentityStore(AppIdentityErrorDescriber describer, UserRepository userRepository, UserClaimRepository userClaimRepository, IUserManager userManager, IUserClaimManager userClaimManager) : base(describer)
{
_userRepository = userRepository;
_userClaimRepository = userClaimRepository;
_userManager = userManager;
_userClaimManager = userClaimManager;
}
public WebsiteUserStore()
{
_userRepository = new UserRepository <TUser>();
_userLoginRepository = new UserLoginRepository();
_userClaimRepository = new UserClaimRepository <TUser>();
_userRoleRepository = new UserRoleRepository <TUser>();
}
public UnitOfWorkWebApi(ApplicationContext context) : base(context)
{
/*************Authorization************/
Claims = new ClaimRepository(context);
ClientApplications = new ClientApplicationRepository(context);
ClientApplicationUtils = new ClientApplicationUtilRepository(context);
RoleClaims = new RoleClaimRepository(context);
RoleEntityClaims = new RoleEntityClaimRepository(context);
Roles = new RoleRepository(context);
UserClaims = new UserClaimRepository(context);
UserEntityClaims = new UserEntityClaimRepository(context);
Users = new UserRepository(context);
UserRoles = new UserRoleRepository(context);
UserUtils = new UserUtilRepository(context);
Applications = new ApplicationRepository(context);
ApplicationUsers = new ApplicationUserRepository(context);
/*************Authorization************/
/*************Instances************/
Matches = new MatchRepository(context);
Teams = new TeamRepository(context);
Players = new PlayerRepository(context);
Stats = new StatRepository(context);
/*********End of Instances*********/
}
public UnitOfWork(ApplicationDbContext context)
{
_context = context;
Attempts = new AttemptRepository(_context);
Exams = new ExamRepository(_context);
Images = new ImageRepository(_context);
NoteParameters = new NoteParameterRepository(_context);
Notifications = new NotificationRepository(_context);
Notes = new NoteRepository(_context);
Opinions = new OpinionRepository(_context);
Options = new OptionRepository(_context);
Passages = new PassageRepository(_context);
Questions = new QuestionRepository(_context);
Requirements = new RequirementRepository(_context);
Roles = new RoleRepository(_context);
RoleClaims = new RoleClaimRepository(_context);
Standards = new StandardRepository(_context);
Sittings = new SittingRepository(_context);
Topics = new TopicRepository(_context);
Users = new UserRepository(_context);
UserClaims = new UserClaimRepository(_context);
UserLogins = new UserLoginRepository(_context);
UserRoles = new UserRoleRepository(_context);
UserTokens = new UserTokenRepository(_context);
}
public MySqlUserStore(string connectionStringName)
{
_connectionString = ConfigurationManager.ConnectionStrings[connectionStringName].ConnectionString;
_userRepository = new UserRepository <TUser>(_connectionString);
_userLoginRepository = new UserLoginRepository(_connectionString);
_userClaimRepository = new UserClaimRepository <TUser>(_connectionString);
_userRoleRepository = new UserRoleRepository <TUser>(_connectionString);
}
public virtual async Task RemoveClaimAsync(TUser user, Claim claim)
{
user.CheckNotNull("user");
claim.CheckNotNull("claim");
string type = claim.Type;
string value = claim.Value;
await UserClaimRepository.DeleteAsync(m => m.User.Id.Equals(user.Id) && m.ClaimType == type && m.ClaimValue == value);
}
public MySqlUserStore()
{
_connectionString = MySqlConnectionWrapper.ConnectionString;
_userRepository = new UserRepository <TUser>(_connectionString);
_userLoginRepository = new UserLoginRepository(_connectionString);
_userClaimRepository = new UserClaimRepository <TUser>(_connectionString);
_userRoleRepository = new UserRoleRepository <TUser>(_connectionString);
}
public FluentNHibernateUserStore(ProviderTypeEnum providerType, string nameOrConnectionString,
FluentNHibernatePersistenceBuilderOptions options = null)
{
_userRepository = new UserRepository <TUser>(providerType, nameOrConnectionString, options);
_userLoginRepository = new UserLoginRepository(_userRepository.SessionFactoryKey);
_userClaimRepository = new UserClaimRepository <TUser>(_userRepository.SessionFactoryKey);
_userRoleRepository = new UserRoleRepository <TUser>(_userRepository.SessionFactoryKey);
}
public virtual async Task AddClaimAsync(TUser user, Claim claim)
{
user.CheckNotNull("user");
claim.CheckNotNull("claim");
TUserClaim userClaim = new TUserClaim()
{
ClaimType = claim.Type, ClaimValue = claim.Value, User = user
};
await UserClaimRepository.InsertAsync(userClaim);
}
public UnitOfWorkAuthorization(AuthorizationContext context) : base(context)
{
Claims = new ClaimRepository(context);
ClientApplications = new ClientApplicationRepository(context);
ClientApplicationUtils = new ClientApplicationUtilRepository(context);
RoleClaims = new RoleClaimRepository(context);
RoleEntityClaims = new RoleEntityClaimRepository(context);
Roles = new RoleRepository(context);
UserClaims = new UserClaimRepository(context);
UserEntityClaims = new UserEntityClaimRepository(context);
Users = new UserRepository(context);
UserRoles = new UserRoleRepository(context);
UserUtils = new UserUtilRepository(context);
Applications = new ApplicationRepository(context);
ApplicationUsers = new ApplicationUserRepository(context);
}
private void InitRepositories()
{
// Ubication
Countries = new CountryRepository(this);
States = new StateRepository(this);
Cities = new CityRepository(this);
// Authorization
Users = new UserRepository(this);
UsersRoles = new UserRoleRepository(this);
UsersLogins = new UserLoginRepository(this);
Roles = new RoleRepository(this);
RoleControls = new RoleControlRepository(this);
UserClaims = new UserClaimRepository(this);
RefreshTokens = new RefreshTokenRepository(this);
}
public Task AddClaimAsync(TUser user, Claim claim)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (claim == null)
{
throw new ArgumentNullException("claim");
}
UserClaimRepository.Insert(new IdentityUserClaim {
UserId = user.Id, ClaimType = claim.Type, ClaimValue = claim.Value
});
return(Task.FromResult <object>(null));
}
public Task RemoveClaimAsync(TUser user, Claim claim)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
if (claim == null)
{
throw new ArgumentNullException("claim");
}
UserClaimRepository.Delete(UserClaimRepository.GetByWhere(new Dictionary <string, object> {
{ "UserId", user.Id },
{ "ClaimType", claim.Type },
{ "ClaimValue", claim.Value }
}).First());
return(Task.FromResult <object>(null));
}
public Task <IList <Claim> > GetClaimsAsync(TUser user)
{
if (user == null)
{
return(Task.FromResult <IList <Claim> >(new List <Claim>()));
}
var where = new Dictionary <string, object> {
{ "UserId", user.Id }
};
if (UserClaimRepository == null)
{
return(Task.FromResult <IList <Claim> >(new List <Claim>()));
}
var userClaims = UserClaimRepository.GetByWhere(where).ToList();
if (!userClaims.Any())
{
return(Task.FromResult <IList <Claim> >(new List <Claim>()));
}
var claims = userClaims.Select(x => new Claim(x.ClaimType, x.ClaimValue));
return(Task.FromResult <IList <Claim> >(claims.ToList()));
}
public static async Task CleanDatabase()
{
IDataGateway dataGateway = new SQLServerGateway();
IConnectionStringData connectionString = new ConnectionStringData();
IUserAccountRepository userAccountRepository = new UserAccountRepository(dataGateway, connectionString);
IUserProfileRepository userProfileRepository = new UserProfileRepository(dataGateway, connectionString);
IUserAccountCodeRepository userAccountCodeRepository = new UserAccountCodeRepository(dataGateway, connectionString);
IUserAccountSettingsRepository userAccountSettingsRepository = new UserAccountSettingRepository(dataGateway, connectionString);
ILoginAttemptsRepository loginAttemptsRepository = new LoginAttemptsRepository(dataGateway, connectionString);
IResourceRepository resourceRepository = new ResourceRepository(dataGateway, connectionString);
IClaimRepository claimRepository = new ClaimRepository(dataGateway, connectionString);
IScopeRepository scopeRepository = new ScopeRepository(dataGateway, connectionString);
IScopeClaimRepository scopeClaimRepository = new ScopeClaimRepository(dataGateway, connectionString);
IUserScopeRepository userScopeRepository = new UserScopeRepository(dataGateway, connectionString);
IUserClaimRepository userClaimRepository = new UserClaimRepository(dataGateway, connectionString);
IAssignmentPolicyRepository assignmentPolicyRepository = new AssignmentPolicyRepository(dataGateway, connectionString);
IAssignmentPolicyPairingRepository assignmentPolicyPairingRepository = new AssignmentPolicyPairingRepository(dataGateway, connectionString);
IUserScopeClaimRepository userScopeClaimRepository = new UserScopeClaimRepository(dataGateway, connectionString);
IAccessPolicyRepository accessPolicyRepository = new AccessPolicyRepository(dataGateway, connectionString);
IAccessPolicyPairingRepository accessPolicyPairingRepository = new AccessPolicyPairingRepository(dataGateway, connectionString);
ITraditionalListingSearchRepository traditionalListingSearchRepository = new TraditionalListingSearchRepository(dataGateway, connectionString);
var accounts = await userAccountRepository.GetAllAccounts();
var profiles = await userProfileRepository.GetAllUserProfiles();
var accountCodes = await userAccountCodeRepository.GetAllUserAccountCodes();
var accountSettings = await userAccountSettingsRepository.GetAllSettings();
var loginAttempts = await loginAttemptsRepository.GetAllLoginAttempts();
var resources = await resourceRepository.GetAllResources();
var claims = await claimRepository.GetAllClaims();
var scopes = await scopeRepository.GetAllScopes();
var scopeClaims = await scopeClaimRepository.GetAllScopeClaims();
var userClaims = await userClaimRepository.GetAllUserClaims();
var userScopes = await userScopeRepository.GetAllUserScopes();
var assignmentPolicies = await assignmentPolicyRepository.GetAllAssignmentPolicies();
var assignmentPolicyPairings = await assignmentPolicyPairingRepository.GetAllAssignmentPolicyPairings();
var userScopeClaims = await userScopeClaimRepository.GetAllUserScopeClaims();
var accessPolicies = await accessPolicyRepository.GetAllAccessPolicies();
var accesssPolicyPairings = await accessPolicyPairingRepository.GetAllAccessPoliciesPairings();
var listings = await traditionalListingSearchRepository.GetAllListings();
var collaborationListings = await traditionalListingSearchRepository.GetAllCollaborationListings();
var relationshipListings = await traditionalListingSearchRepository.GetAllRelationshipListings();
var teamListings = await traditionalListingSearchRepository.GetAllTeamListings();
if (resources != null)
{
await DeleteAllFromTable("Resource");
await ReseedAsync("Resource", 0, connectionString, dataGateway);
}
if (claimRepository != null)
{
await DeleteAllFromTable("Claim");
await ReseedAsync("Claim", 0, connectionString, dataGateway);
}
if (scopeRepository != null)
{
await DeleteAllFromTable("Scope");
await ReseedAsync("Scope", 0, connectionString, dataGateway);
}
if (scopeClaims != null)
{
await DeleteAllFromTable("ScopeClaim");
await ReseedAsync("ScopeClaim", 0, connectionString, dataGateway);
}
if (assignmentPolicies != null)
{
await DeleteAllFromTable("AssignmentPolicy");
await ReseedAsync("AssignmentPolicy", 0, connectionString, dataGateway);
}
if (assignmentPolicyPairings != null)
{
await DeleteAllFromTable("AssignmentPolicyPairing");
}
if (userScopeClaims != null)
{
await DeleteAllFromTable("UserScopeClaim");
await ReseedAsync("UserScopeClaim", 0, connectionString, dataGateway);
}
if (userScopes != null)
{
await DeleteAllFromTable("UserScope");
await ReseedAsync("UserScope", 0, connectionString, dataGateway);
}
if (userClaims != null)
{
await DeleteAllFromTable("UserClaim");
await ReseedAsync("UserClaim", 0, connectionString, dataGateway);
}
if (accessPolicies != null)
{
await DeleteAllFromTable("AccessPolicy");
await ReseedAsync("AccessPolicy", 0, connectionString, dataGateway);
}
if (accesssPolicyPairings != null)
{
await DeleteAllFromTable("AccessPolicyPairing");
await ReseedAsync("AssignmentPolicyPairing", 0, connectionString, dataGateway);
await ReseedAsync("AccessPolicyPairing", 0, connectionString, dataGateway);
}
if (loginAttempts != null)
{
await DeleteAllFromTable("LoginAttempts");
await ReseedAsync("LoginAttempts", 0, connectionString, dataGateway);
}
if (accounts != null)
{
await DeleteAllFromTable("UserProfile");
await DeleteAllFromTable("UserAccountSettings");
await DeleteAllFromTable("UserAccountCode");
await DeleteAllFromTable("UserAccount");
await ReseedAsync("UserAccount", 0, connectionString, dataGateway);
await ReseedAsync("UserProfile", 0, connectionString, dataGateway);
await ReseedAsync("UserAccountCode", 0, connectionString, dataGateway);
await ReseedAsync("UserAccountSettings", 0, connectionString, dataGateway);
}
if (listings != null)
{
await DeleteAllFromTable("Listing");
await ReseedAsync("Listing", 0, connectionString, dataGateway);
}
if (collaborationListings != null)
{
await DeleteAllFromTable("Collaboration");
await ReseedAsync("Collaboration", 0, connectionString, dataGateway);
}
if (relationshipListings != null)
{
await DeleteAllFromTable("Relationship");
await ReseedAsync("Relationship", 0, connectionString, dataGateway);
}
if (teamListings != null)
{
await DeleteAllFromTable("TeamModel");
await ReseedAsync("TeamModel", 0, connectionString, dataGateway);
}
}
