/// <summary>
/// C-tor. Mongo DB connection.
/// </summary>
/// <param name="identityDbSettings"></param>
public UserService(IdentityDatabase identityDbSettings)
{
if (identityDbSettings == null)
{
throw new ArgumentNullException(nameof(identityDbSettings), "Introvert Database invalid settings. Check appsettings file.");
}
if (String.IsNullOrWhiteSpace(identityDbSettings.ConnectionString) ||
String.IsNullOrWhiteSpace(identityDbSettings.Server) ||
String.IsNullOrWhiteSpace(identityDbSettings.Username) ||
String.IsNullOrWhiteSpace(identityDbSettings.Password) ||
String.IsNullOrWhiteSpace(identityDbSettings.Database))
{
throw new ArgumentNullException(nameof(identityDbSettings), "Introvert Database invalid property settings. Check appsettings file.");
}
try
{
string connectionString = identityDbSettings.ConnectionString;
connectionString = connectionString.Replace("<server>", identityDbSettings.Server);
connectionString = connectionString.Replace("<username>", identityDbSettings.Username);
connectionString = connectionString.Replace("<password>", identityDbSettings.Password);
MongoClient client = new MongoClient(connectionString);
IMongoDatabase database = client.GetDatabase(identityDbSettings.Database);
_userRepository = database.GetCollection <UserEntity>(nameof(UserEntity) + "Collection");
}
catch (Exception ex)
{
// log or manage the exception
// TODO: create a logger
throw ex;
}
}
public async Task <bool> GetPhoneNumberConfirmedAsync(IdentityUser user)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
return((await db.Users.GetAsync(user.Id)).PhoneNumberConfirmed);
}
}
public async Task DeleteAsync(IdentityRole role)
{
using (SqlConnection conn = new SqlConnection())
{
var db = IdentityDatabase.Init(conn, 2);
await db.Roles.DeleteAsync(role.Id);
}
}
public async Task <bool> GetTwoFactorEnabledAsync(IdentityUser user)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
return((await db.Users.GetAsync(user.Id)).TwoFactorEnabled);
}
}
public async Task DeleteAsync(IdentityUser user)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
await db.Users.DeleteAsync(user.Id);
}
}
public async Task <string> GetEmailAsync(IdentityUser user)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
return((await db.Users.GetAsync(user.Id)).Email);
}
}
public UserController(IdentityDatabase context
, UserManager <ApplicationUser> userManager
, SignInManager <ApplicationUser> signInManager
, IMemoryCache cache) : base(userManager, signInManager, cache)
{
_context = context ?? throw new ArgumentNullException(nameof(context));
//_userManager = userManager;
//_signInManager = signInManager;
//this._cache = cache;
}
public async Task <bool> HasPasswordAsync(IdentityUser user)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
return(!string.IsNullOrEmpty(u.PasswordHash));
}
}
private UserController PrepareController(List <ApplicationUser> users, ApplicationUserManager userManager)
{
var dbContext = new Mock <IIdentityDbContext <ApplicationUser> >();
var rolesSet = Testing.Mocks.GetQueryableMockedDbSet <IdentityRole>(_roles);
var usersSet = Testing.Mocks.GetQueryableMockedDbSet <ApplicationUser>(users);
dbContext.Setup(m => m.Roles).Returns(() => rolesSet);
dbContext.Setup(m => m.Users).Returns(() => usersSet);
var database = new IdentityDatabase(dbContext.Object);
return(new UserController(database, userManager));
}
public async Task CreateAsync(IdentityUser user)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
var result = await FindByEmailAsync(user.Email);
if (result == null)
{
await db.Users.InsertAsync(user);
}
}
}
public async Task SetEmailAsync(IdentityUser user, string email)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
if (u != null)
{
u.Email = email;
await db.Users.UpdateAsync(u.Id, u);
}
}
}
public async Task AddClaimAsync(IdentityUser user, Claim claim)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
var instance = new IdentityUserClaim
{
UserId = user.Id,
ClaimType = claim.Type,
ClaimValue = claim.Value,
};
await db.UserClaims.InsertAsync(instance);
}
}
public async Task SetTwoFactorEnabledAsync(IdentityUser user, bool enabled)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
if (u != null)
{
u.TwoFactorEnabled = enabled;
await db.Users.UpdateAsync(u.Id, u);
}
}
}
public async Task SetPasswordHashAsync(IdentityUser user, string passwordHash)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
if (u != null)
{
u.PasswordHash = passwordHash;
await db.Users.UpdateAsync(u.Id, u);
}
}
}
public async Task SetPhoneNumberConfirmedAsync(IdentityUser user, bool confirmed)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
if (u != null)
{
u.PhoneNumberConfirmed = confirmed;
await db.Users.UpdateAsync(u.Id, u);
}
}
}
public async Task AddLoginAsync(IdentityUser user, UserLoginInfo login)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
var instance = new IdentityUserLogin
{
UserId = user.Id,
LoginProvider = login.LoginProvider,
ProviderKey = login.ProviderKey,
};
await db.UserLogins.InsertAsync(instance);
}
}
public async Task SetSecurityStampAsync(IdentityUser user, string stamp)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
if (u == null)
{
throw new InvalidOperationException("Cannot find a user to set the security stamp.");
}
u.SecurityStamp = stamp;
await db.Users.UpdateAsync(u.Id, u);
}
}
public static IdentityDatabase Create()
{
IdentityDatabase connection = null;
using (StreamReader file = new StreamReader(jsonsPath))
{
JObject json = JObject.Parse(file.ReadToEnd());
if (json.TryGetValue(databaseSection, StringComparison.CurrentCulture, out JToken jToken))
{
if (jToken != null)
{
connection = JsonConvert.DeserializeObject <IdentityDatabase>(jToken.ToString());
}
}
}
return(connection);
}
public async Task AddToRoleAsync(IdentityUser user, string roleName)
{
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityRole role = (await conn.QueryAsync <IdentityRole>(@"select * from Roles where Name=@RoleName", new { RoleName = roleName })).SingleOrDefault();
if (role == null)
{
throw new InvalidOperationException(string.Format("Role {0} not found.", roleName));
}
var instance = new IdentityUserRole
{
RoleId = role.Id,
UserId = user.Id,
};
await db.UserRoles.InsertAsync(instance);
}
}
private async Task SetUserField(IdentityUser user, string fieldName, object value)
{
var pi = user.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public).SingleOrDefault(x => x.Name == fieldName);
if (pi == null)
{
throw new ArgumentException(string.Format("Property name {0} does not exist for type IdentityUser.", fieldName));
}
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
if (u != null)
{
pi.SetValue(u, value);
await db.Users.UpdateAsync(u.Id, u);
}
}
}
public async Task <int> IncrementAccessFailedCountAsync(IdentityUser user)
{
//int result;
using (SqlConnection conn = new SqlConnection(ConnectionString))
{
var db = IdentityDatabase.Init(conn, 2);
IdentityUser u = await db.Users.GetAsync(user.Id);
if (u == null)
{
throw new ArgumentException("Cannot find user.");
}
int result = u.AccessFailedCount++;
await db.Users.UpdateAsync(u.Id, u);
return(result);
}
//return result;
}
public UserController(IdentityDatabase database, ApplicationUserManager userManager)
{
_database = database;
_userManager = userManager;
}
public AccountController(IdentityDatabase database, ApplicationUserManager userManager, ApplicationSignInManager signInManager)
{
_database = database;
_userManager = userManager;
_signInManager = signInManager;
}
public ApplicationRoleStore(IdentityDatabase context, IdentityErrorDescriber errorDescriber = null)
{
ErrorDescriber = errorDescriber;
Context = context ?? throw new ArgumentNullException(nameof(context));
}
public void Setup()
{
IdentityDatabase identityDatabase = ConnectionHelper.Create();
_userService = new UserService(identityDatabase);
}
public DataAccessTests()
{
_database = new IdentityDatabase();
}
