/// <summary>
/// Custom GetRoleClaimHistory Method
/// </summary>
/// <param name="userRoleClaimId">string</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<List<AspNetUserRoleClaimHistory>></returns>
/// <method>GetRoleClaimHistory(CancellationToken cancellationToken)</method>
public async Task <List <AspNetUserRoleClaimHistory> > GetRoleClaimHistory(string userRoleClaimId, CancellationToken cancellationToken)
{
try
{
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(userRoleClaimId.Clean());
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/RoleClaimHistory", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken);
List <AspNetUserRoleClaimHistory> history = JsonConvert.DeserializeObject <List <AspNetUserRoleClaimHistory> >(jsonString);
return(history);
}
catch (Exception exception)
{
_logger.Exception(exception);
throw;
}
}
/// <summary>
/// Implemented IUserClaimStore GetUsersForClaimAsync Method
/// </summary>
/// <param name="claim">Claim</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task</returns>
/// <method>GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken)</method>
public async Task <IList <ApplicationUser> > GetUsersForClaimAsync(Claim claim, CancellationToken cancellationToken)
{
try
{
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(claim, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/FindByClaim", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken);
List <ApplicationUser> users = JsonConvert.DeserializeObject <List <ApplicationUser> >(jsonString);
return(users);
}
catch (Exception exception)
{
_logger.Exception(exception);
throw;
}
}
/// <summary>
/// Implemented IUserEmailStore FindByEmailAsync Method
/// </summary>
/// <param name="normalizedEmail">string</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<ApplicationUser></returns>
/// <method>FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)</method>
public async Task <ApplicationUser> FindByEmailAsync(string normalizedEmail, CancellationToken cancellationToken)
{
try
{
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(normalizedEmail.Clean().ToUpper());
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/FindByNormalizedEmail", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken);
ApplicationUser user = JsonConvert.DeserializeObject <ApplicationUser>(jsonString);
return(user);
}
catch (Exception exception)
{
_logger.Exception(exception);
throw;
}
}
/// <summary>
/// Custom GetApprovedUsersAsync Method
/// </summary>
/// <param name="roleId">string</param>
/// <param name="roleClaimId">int</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<List<ApplicationUser>></returns>
/// <method>GetApprovedUsersAsync(string roleId, int roleClaimId, CancellationToken cancellationToken = default(CancellationToken))</method>
public async Task <List <ApplicationUser> > GetApprovedUsersAsync(string roleId, int roleClaimId, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(new KeyValuePair <string, int>(roleId.Clean(), roleClaimId));
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "Role/GetApprovedUsers", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken);
List <ApplicationUser> users = JsonConvert.DeserializeObject <List <ApplicationUser> >(jsonString);
return(users);
}
catch (Exception exception)
{
_logger.Exception(exception);
throw;
}
}
/// <summary>
/// Implemented IUserLoginStore FindByLoginAsync Method
/// </summary>
/// <param name="loginProvider">string</param>
/// <param name="providerKey">string</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<ApplicationUser></returns>
/// <method>FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)</method>
public async Task <ApplicationUser> FindByLoginAsync(string loginProvider, string providerKey, CancellationToken cancellationToken)
{
try
{
IdentityUserLogin <string> input = new IdentityUserLogin <string>();
input.LoginProvider = loginProvider.Clean();
input.ProviderKey = providerKey.Clean();
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(input);
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/FindByLogin", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken);
ApplicationUser user = JsonConvert.DeserializeObject <ApplicationUser>(jsonString);
return(user);
}
catch (Exception exception)
{
_logger.Exception(exception);
throw;
}
}
/// <summary>
/// Method to save a record in a dictonary of key value records in cookie
/// </summary>
/// <param name="cookieKey">string</param>
/// <param name="key">string</param>
/// <param name="value">string</param>
/// <exception>Requires HttpRequest and HttpResponse</exception>
/// <method>SetValue(string cookiekey, string key, string value)</method>
public void SetValue(string cookieKey, string key, string value)
{
if (_request == null)
{
throw new Exception("Invalid operation, request cannot be null");
}
if (_response == null)
{
throw new Exception("Invalid operation, response cannot be null");
}
Dictionary <string, string> form = new Dictionary <string, string>();
if (_request.Cookies[cookieKey] != null)
{
var cookieValue = _request.Cookies[cookieKey];
form = JsonConvert.DeserializeObject <Dictionary <string, string> >(cookieValue);
}
if (form.ContainsKey(key))
{
form.Remove(key);
}
form.Add(key, AESGCM.Encrypt(value));
_response.Cookies.Append(cookieKey, JsonConvert.SerializeObject(form), _cookieOptions);
}
public IActionResult Post(object encryptObject)
{
try
{
IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers;
string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault();
if (string.IsNullOrEmpty(accessToken))
{
return(BadRequest("Invalid Authorization"));
}
accessToken = accessToken.Substring(7);
string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken);
string input = JsonConvert.DeserializeObject <string>(jsonString);
ApplicationRole role = _dbContext.Roles
.Include("RoleClaims")
.Where(x => x.Id == input)
.FirstOrDefault();
jsonString = JsonConvert.SerializeObject(role, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
return(new JsonResult(encryptString));
}
catch (Exception exception)
{
_logger.Exception(exception);
return(BadRequest(exception));
}
}
/// <summary>
/// Implemented IRoleStore Method
/// </summary>
/// <param name="roleId">string</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<ApplicationRole></returns>
/// <method>FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken))</method>
public async Task <ApplicationRole> FindByIdAsync(string roleId, CancellationToken cancellationToken = default(CancellationToken))
{
try
{
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(roleId.Clean());
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "Role/FindById", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
jsonString = AESGCM.Decrypt(jsonClient.GetResponseObject <string>(), accessToken);
ApplicationRole role = JsonConvert.DeserializeObject <ApplicationRole>(jsonString);
return(role);
}
catch (Exception exception)
{
_logger.Exception(exception);
throw;
}
}
public byte[] Encrypt(byte[] payload)
{
var disposablePrivateKey = PrivateKey.Generate();
var aesKey = disposablePrivateKey.ECDH(this);
var aes = new AESGCM(aesKey);
return(aes.Encrypt(payload, disposablePrivateKey.PublicKey.Format(true)));
}
/// <summary>
/// Implemented IUserStore DeleteAsync Method
/// </summary>
/// <param name="user">ApplicationUser</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<IdentityResult></returns>
/// <method>DeleteAsync(ApplicationUser user, CancellationToken cancellationToken)</method>
public async Task <IdentityResult> DeleteAsync(ApplicationUser user, CancellationToken cancellationToken)
{
try
{
if (user.RevokedDate == (DateTime?)DateTime.MinValue)
{
throw new Exception("Missing required revoked date");
}
if (string.IsNullOrEmpty(user.RevokedById))
{
throw new Exception("Missing required revoked by");
}
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(user);
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/Update", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Warning(jsonClient.GetResponseString());
return(IdentityResult.Failed(
new IdentityError()
{
Code = jsonClient.StatusCode.ToString(),
Description = jsonClient.GetResponseString()
}
));
}
}
catch (Exception exception)
{
_logger.Exception(exception);
return(IdentityResult.Failed(
new IdentityError
{
Code = exception.Source,
Description = exception.Message
}
));
}
return(IdentityResult.Success);
}
public IActionResult Post(object encryptObject)
{
try
{
IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers;
string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault();
if (string.IsNullOrEmpty(accessToken))
{
return(BadRequest("Invalid Authorization"));
}
accessToken = accessToken.Substring(7);
string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken);
IdentityUserLogin <string> input = JsonConvert.DeserializeObject <IdentityUserLogin <string> >(jsonString);
ApplicationUser user = _dbContext.Users
.Join(_dbContext.UserLogins, Users => Users.Id, UserLogins => UserLogins.UserId, (Users, UserLogins) => new { Users, UserLogins })
.Where(x => x.UserLogins.ProviderKey == input.ProviderKey)
.Where(x => x.UserLogins.LoginProvider == input.LoginProvider)
.Select(x => x.Users)
.Include("Claims")
.Include("Logins")
.Include("Tokens")
.Include("RoleClaims")
//.Include("RoleClaims.User")
.Include("RoleClaims.Role")
.Include("RoleClaims.RoleClaim")
.Include("RoleClaims.History")
.Include("RoleClaims.History.ActionBy")
//.Include("RoleClaims.History.UserRoleClaim")
.FirstOrDefault();
jsonString = JsonConvert.SerializeObject(user, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
return(new JsonResult(encryptString));
}
catch (Exception exception)
{
_logger.Exception(exception);
return(BadRequest(exception));
}
}
public IActionResult Post()
{
try
{
IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers;
string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault();
if (string.IsNullOrEmpty(accessToken))
{
return(BadRequest("Invalid Authorization"));
}
accessToken = accessToken.Substring(7);
List <ApplicationUser> users = _dbContext.Users
.Include("Claims")
.Include("Logins")
.Include("Tokens")
.Include("RoleClaims")
//.Include("RoleClaims.User")
.Include("RoleClaims.Role")
.Include("RoleClaims.RoleClaim")
.Include("RoleClaims.History")
.Include("RoleClaims.History.ActionBy")
//.Include("RoleClaims.History.UserRoleClaim")
.Where(x => x.RequestDate > (DateTime?)DateTime.MinValue)
.Where(x => x.EmailConfirmed == true)
.Where(x => x.ApprovedDate == (DateTime?)DateTime.MinValue)
.Where(x => x.RevokedDate == (DateTime?)DateTime.MinValue)
.OrderBy(x => x.RequestDate)
.ToList();
string jsonString = JsonConvert.SerializeObject(users, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
return(new JsonResult(encryptString));
}
catch (Exception exception)
{
_logger.Exception(exception);
return(BadRequest(exception));
}
}
public IActionResult Post(object encryptObject)
{
try
{
IHeaderDictionary headers = _httpContextAccessor.HttpContext.Request.Headers;
string accessToken = headers.Where(x => x.Key == "Authorization").Select(x => x.Value).FirstOrDefault();
if (string.IsNullOrEmpty(accessToken))
{
return(BadRequest("Invalid Authorization"));
}
accessToken = accessToken.Substring(7);
string jsonString = AESGCM.Decrypt(encryptObject.ToString(), accessToken);
KeyValuePair <string, int> input = JsonConvert.DeserializeObject <KeyValuePair <string, int> >(jsonString);
List <ApplicationUser> users = _dbContext.Users
.Join(_dbContext.UserRoleClaims, Users => Users.Id, UserRoleClaims => UserRoleClaims.UserId, (Users, UserRoleClaims) => new { Users, UserRoleClaims })
.Where(x => x.UserRoleClaims.RoleId == input.Key)
.Where(x => x.UserRoleClaims.RoleClaimId == input.Value)
.Where(x => x.UserRoleClaims.Status == AspNetUserRoleClaim.RoleClaimStatus.Approved)
.Select(x => x.Users)
.Include("Claims")
.Include("Logins")
.Include("Tokens")
.Include("RoleClaims")
.Include("RoleClaims.Role")
.Include("RoleClaims.RoleClaim")
.ToList();
jsonString = JsonConvert.SerializeObject(users, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
return(new JsonResult(encryptString));
}
catch (Exception exception)
{
_logger.Exception(exception);
return(BadRequest(exception));
}
}
/// <summary>
/// Implemented IUserStore UpdateAsync Method
/// </summary>
/// <param name="user">ApplicationUser</param>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<IdentityResult></returns>
/// <method>UpdateAsync(ApplicationUser user, CancellationToken cancellationToken)</method>
public async Task <IdentityResult> UpdateAsync(ApplicationUser user, CancellationToken cancellationToken)
{
try
{
string accessToken = await GetAccessToken();
string jsonString = JsonConvert.SerializeObject(user, new JsonSerializerSettings()
{
ReferenceLoopHandling = ReferenceLoopHandling.Ignore
});
string encryptString = AESGCM.Encrypt(jsonString, accessToken);
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/Update", encryptString);
if (!jsonClient.IsResponseSuccess)
{
_logger.Warning(jsonClient.GetResponseString());
return(IdentityResult.Failed(
new IdentityError()
{
Code = jsonClient.StatusCode.ToString(),
Description = jsonClient.GetResponseString()
}
));
}
}
catch (Exception exception)
{
_logger.Exception(exception);
return(IdentityResult.Failed(
new IdentityError
{
Code = exception.Source,
Description = exception.Message
}
));
}
return(IdentityResult.Success);
}
/// <summary>
/// Method to save a dictonary of key value records in cookie
/// </summary>
/// <param name="cookieKey">string</param>
/// <param name="values">Dictionary<string, string></param>
/// <exception>Requires HttpRequest and HttpResponse</exception>
/// <method>SetAllValues(string cookiekey, Dictionary<string, string>)</method>
public void SetAllValues(string cookieKey, Dictionary <string, string> values)
{
if (_request == null)
{
throw new Exception("Invalid operation, request cannot be null");
}
if (_response == null)
{
throw new Exception("Invalid operation, response cannot be null");
}
Dictionary <string, string> form = new Dictionary <string, string>();
foreach (var item in values)
{
form.Add(item.Key, AESGCM.Encrypt(item.Value));
}
_response.Cookies.Append(cookieKey, JsonConvert.SerializeObject(form), _cookieOptions);
}
/// <summary>
/// Method to store encrypted object in Http Session
/// </summary>
/// <param name="session">ISession</param>
/// <param name="key">string</param>
/// <param name="value">T</param>
/// <method>Encrypt<T>(this ISession session, string key, T value)</method>
public static async void Encrypt <T>(this ISession session, string key, T value)
{
session.SetString(key, AESGCM.Encrypt(JsonSerializer.Serialize(value)));
await session.CommitAsync();
}