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>
/// 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 GetPendingRegistrations Method
/// </summary>
/// <param name="cancellationToken">CancellationToken</param>
/// <returns>Task<List<ApplicationUser>></returns>
/// <method>CreateAsync(CancellationToken cancellationToken)</method>
public async Task <List <ApplicationUser> > GetPendingRegistrations(CancellationToken cancellationToken)
{
try
{
string accessToken = await GetAccessToken();
JsonClient jsonClient = new JsonClient(_apiBaseUrl, accessToken);
HttpStatusCode statusCode = await jsonClient.SendRequest(HttpMethod.Post, "User/PendingRegistrations");
if (!jsonClient.IsResponseSuccess)
{
_logger.Exception(new Exception(jsonClient.GetResponseString()));
throw new Exception(jsonClient.GetResponseString());
}
string 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>
/// 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;
}
}
/// <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;
}
}
public IActionResult Post(object encryptObject)
{
using (var dbContextTransaction = _dbContext.Database.BeginTransaction())
{
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);
ApplicationRole input = JsonConvert.DeserializeObject <ApplicationRole>(jsonString);
_dbContext.Roles.Add(input);
_dbContext.SaveChanges();
dbContextTransaction.Commit();
return(Ok());
}
catch (Exception exception)
{
dbContextTransaction.Rollback();
_logger.Exception(exception);
return(BadRequest(exception));
}
}
}
/// <summary>
/// Method to return decrypted object from Http Session
/// </summary>
/// <param name="session">ISession</param>
/// <param name="key">string</param>
/// <returns><T></returns>
/// <method>Decrypt<T>(this ISession session, string key)</method>
public static async Task <T> Decrypt <T>(this ISession session, string key)
{
await session.LoadAsync();
var value = session.GetString(key);
return(value == null ? default : JsonSerializer.Deserialize <T>(AESGCM.Decrypt(value)));
}
public byte[] Decrypt(byte[] payload)
{
var pubKey = PublicKey.FromBytes(payload.Take(33).ToArray());
var aesKey = ECDH(pubKey);
var aes = new AESGCM(aesKey);
return(aes.Decrypt(payload, 33));
}
public void DecryptTest()
{
var key = "349c469e0ea9eb8822658aaf0817a221d7fd4be78b243f455d72b60f9b1a3a4e".ParseHex();
var ciphertext = "1881342a2930cdc2734ae15e143a09fe5b0a5f113b0e2fcfc8d56f23c508a2890d7139c592cf4e4c76758a9b2317cb94".ParseHex();
var expected = Encoding.ASCII.GetBytes("a secret message");
var aes = new AESGCM(key);
var actual = aes.Decrypt(ciphertext);
CollectionAssert.AreEqual(expected, actual);
}
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(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>
/// Method to return dictionary of values for given key stored in cookie
/// </summary>
/// <param name="cookieKey">string</param>
/// <returns>Dictionary<string, string%gt;</returns>
/// <exception>Requires HttpRequest</exception>
/// <method>GetAllValues(string sessionkey)</method>
public Dictionary <string, string> GetAllValues(string cookieKey)
{
if (_request == null)
{
throw new Exception("Invalid operation, request cannot be null");
}
Dictionary <string, string> form = new Dictionary <string, string>();
if (_request.Cookies[cookieKey] != null)
{
var cookieValue = _request.Cookies[cookieKey];
Dictionary <string, string> encryptedForm = JsonConvert.DeserializeObject <Dictionary <string, string> >(cookieValue);
foreach (var item in encryptedForm)
{
form.Add(item.Key, AESGCM.Decrypt(item.Value));
}
}
return(form);
}
/// <summary>
/// Method to return value for given key in dictonary stored in cookie
/// </summary>
/// <param name="cookieKey">string</param>
/// <param name="key">string</param>
/// <returns>string</returns>
/// <exception>Requires HttpRequest</exception>
/// <method>GetValue(string cookieKey, string key)</method>
public string GetValue(string cookieKey, string key)
{
if (_request == null)
{
throw new Exception("Invalid operation, request cannot be null");
}
string value = string.Empty;
if (_request.Cookies[cookieKey] != null)
{
var cookieValue = _request.Cookies[cookieKey];
Dictionary <string, string> form = JsonConvert.DeserializeObject <Dictionary <string, string> >(cookieValue);
if (form.ContainsKey(key))
{
value = AESGCM.Decrypt(form[key]);
}
}
return(value);
}
public IActionResult Post(object encryptObject)
{
using (var dbContextTransaction = _dbContext.Database.BeginTransaction())
{
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);
ApplicationRole input = JsonConvert.DeserializeObject <ApplicationRole>(jsonString);
ApplicationRole role = _dbContext.Roles
.Include("RoleClaims")
.Where(x => x.Id == input.Id)
.FirstOrDefault();
if (role != null)
{
if (role.ConcurrencyStamp != input.ConcurrencyStamp)
{
role.ConcurrencyStamp = input.ConcurrencyStamp;
}
if (role.Name != input.Name)
{
role.Name = input.Name;
role.NormalizedName = input.NormalizedName.Trim().ToUpper();
}
// remove Claims
foreach (ApplicationRoleClaim roleClaim in role.RoleClaims.ToArray())
{
var inputClaim = input.RoleClaims
.Where(x => x.ClaimType.Trim().ToUpper() == roleClaim.ClaimType.Trim().ToUpper() && x.ClaimValue.Trim().ToUpper() == roleClaim.ClaimValue.Trim().ToUpper())
.FirstOrDefault();
if (inputClaim == null)
{
role.RoleClaims.Remove(roleClaim);
_dbContext.Entry(roleClaim).State = EntityState.Deleted;
}
}
// add Claims
foreach (ApplicationRoleClaim inputClaim in input.RoleClaims)
{
var roleClaim = role.RoleClaims
.Where(x => x.ClaimType.Trim().ToUpper() == inputClaim.ClaimType.Trim().ToUpper() && x.ClaimValue.Trim().ToUpper() == inputClaim.ClaimValue.Trim().ToUpper())
.FirstOrDefault();
if (roleClaim == null)
{
role.RoleClaims.Add(inputClaim);
}
}
// save changes
if (_dbContext.HasUnsavedChanges())
{
_dbContext.Roles.Update(role);
_dbContext.SaveChanges();
dbContextTransaction.Commit();
}
}
return(Ok());
}
catch (Exception exception)
{
dbContextTransaction.Rollback();
_logger.Exception(exception);
return(BadRequest(exception));
}
}
}
public IActionResult Post(object encryptObject)
{
using (var dbContextTransaction = _dbContext.Database.BeginTransaction())
{
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);
ApplicationUser input = JsonConvert.DeserializeObject <ApplicationUser>(jsonString);
ApplicationUser user = _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.Id == input.Id)
.FirstOrDefault();
if (user != null)
{
if (user.AccessFailedCount != input.AccessFailedCount)
{
user.AccessFailedCount = input.AccessFailedCount;
}
if (user.ApprovedById != input.ApprovedById)
{
user.ApprovedById = input.ApprovedById;
}
if (user.ApprovedDate != input.ApprovedDate)
{
user.ApprovedDate = input.ApprovedDate;
}
if (user.ConcurrencyStamp != input.ConcurrencyStamp)
{
user.ConcurrencyStamp = input.ConcurrencyStamp;
}
if (user.Email != input.Email)
{
user.Email = input.Email;
user.NormalizedEmail = input.Email.Trim().ToUpper();
}
if (user.EmailConfirmed != input.EmailConfirmed)
{
user.EmailConfirmed = input.EmailConfirmed;
}
if (user.UserName != input.UserName)
{
user.UserName = input.UserName;
user.NormalizedUserName = input.UserName.Trim().ToUpper();
}
if (user.FirstName != input.FirstName)
{
user.FirstName = input.FirstName;
}
if (user.LastName != input.LastName)
{
user.LastName = input.LastName;
}
if (user.LockoutEnabled != input.LockoutEnabled)
{
user.LockoutEnabled = input.LockoutEnabled;
}
if (user.LockoutEnd != input.LockoutEnd)
{
user.LockoutEnd = input.LockoutEnd;
}
if (user.PasswordHash != input.PasswordHash)
{
user.PasswordHash = input.PasswordHash;
}
if (user.PhoneNumber != input.PhoneNumber)
{
user.PhoneNumber = input.PhoneNumber;
}
if (user.PhoneNumberConfirmed != input.PhoneNumberConfirmed)
{
user.PhoneNumberConfirmed = input.PhoneNumberConfirmed;
}
if (user.RequestDate != input.RequestDate)
{
user.RequestDate = input.RequestDate;
}
if (user.RevokedById != input.RevokedById)
{
user.RevokedById = input.RevokedById;
}
if (user.RevokedDate != input.RevokedDate)
{
user.RevokedDate = input.RevokedDate;
}
if (user.TwoFactorEnabled != input.TwoFactorEnabled)
{
user.TwoFactorEnabled = input.TwoFactorEnabled;
}
// remove Claims
foreach (IdentityUserClaim <string> userClaim in user.Claims.ToArray())
{
var inputClaim = input.Claims
.Where(x => x.ClaimType.Trim().ToUpper() == userClaim.ClaimType.Trim().ToUpper() && x.ClaimValue.Trim().ToUpper() == userClaim.ClaimValue.Trim().ToUpper())
.FirstOrDefault();
if (inputClaim == null)
{
user.Claims.Remove(userClaim);
_dbContext.Entry(userClaim).State = EntityState.Deleted;
}
}
// add Claims
foreach (IdentityUserClaim <string> inputClaim in input.Claims)
{
var userClaim = user.Claims.ToArray()
.Where(x => x.ClaimType.Trim().ToUpper() == inputClaim.ClaimType.Trim().ToUpper() && x.ClaimValue.Trim().ToUpper() == inputClaim.ClaimValue.Trim().ToUpper())
.FirstOrDefault();
if (userClaim == null)
{
user.Claims.Add(inputClaim);
}
}
// remove Logins
foreach (IdentityUserLogin <string> userLogin in user.Logins.ToArray())
{
var inputLogin = input.Logins
.Where(x => x.LoginProvider.Trim().ToUpper() == userLogin.LoginProvider.Trim().ToUpper() && x.ProviderKey.Trim().ToUpper() == userLogin.ProviderKey.Trim().ToUpper())
.FirstOrDefault();
if (inputLogin == null)
{
user.Logins.Remove(userLogin);
_dbContext.Entry(userLogin).State = EntityState.Deleted;
}
}
// add Logins
foreach (IdentityUserLogin <string> inputLogin in input.Logins)
{
var userLogin = user.Logins.ToArray()
.Where(x => x.LoginProvider.Trim().ToUpper() == inputLogin.LoginProvider.Trim().ToUpper() && x.ProviderKey.Trim().ToUpper() == inputLogin.ProviderKey.Trim().ToUpper())
.FirstOrDefault();
if (userLogin == null)
{
user.Logins.Add(inputLogin);
}
}
// remove Tokens
foreach (IdentityUserToken <string> userToken in user.Tokens.ToArray())
{
var inputToken = input.Tokens
.Where(x => x.LoginProvider.Trim().ToUpper() == userToken.LoginProvider.Trim().ToUpper() && x.Name.Trim().ToUpper() == userToken.Name.Trim().ToUpper() && x.Value.Trim().ToUpper() == userToken.Value.Trim().ToUpper())
.FirstOrDefault();
if (inputToken == null)
{
user.Tokens.Remove(userToken);
_dbContext.Entry(userToken).State = EntityState.Deleted;
}
}
// add Tokens
foreach (IdentityUserToken <string> inputToken in input.Tokens)
{
var userToken = user.Tokens.ToArray()
.Where(x => x.LoginProvider.Trim().ToUpper() == inputToken.LoginProvider.Trim().ToUpper() && x.Name.Trim().ToUpper() == inputToken.Name.Trim().ToUpper() && x.Value.Trim().ToUpper() == inputToken.Value.Trim().ToUpper())
.FirstOrDefault();
if (userToken == null)
{
user.Tokens.Add(inputToken);
}
}
// remove RoleClaims
foreach (AspNetUserRoleClaim userRoleClaim in user.RoleClaims.ToArray())
{
user.RoleClaims.Remove(userRoleClaim);
_dbContext.Entry(userRoleClaim).State = EntityState.Deleted;
}
// add RoleClaims
foreach (AspNetUserRoleClaim inputRoleClaim in input.RoleClaims)
{
var userRoleClaim = user.RoleClaims
.Where(x => x.RoleId == inputRoleClaim.RoleId &&
x.RoleClaimId == inputRoleClaim.RoleClaimId)
.FirstOrDefault();
if (userRoleClaim == null)
{
if (inputRoleClaim.User == null)
{
inputRoleClaim.User = user;
}
foreach (AspNetUserRoleClaimHistory inputHistory in inputRoleClaim.History)
{
if (inputHistory.UserRoleClaim == null)
{
inputHistory.UserRoleClaim = inputRoleClaim;
}
_dbContext.Entry(inputHistory).State = EntityState.Added;
}
user.RoleClaims.Add(inputRoleClaim);
_dbContext.Entry(inputRoleClaim).State = EntityState.Added;
}
}
// save changes
if (_dbContext.HasUnsavedChanges())
{
_dbContext.Users.Update(user);
_dbContext.SaveChanges();
dbContextTransaction.Commit();
}
}
return(Ok());
}
catch (Exception exception)
{
dbContextTransaction.Rollback();
_logger.Exception(exception);
return(BadRequest(exception));
}
}
}