public Task <TUser> FindAsync(UserLoginInfo login)
{
if (login == null)
{
throw new ArgumentNullException("parameter not valid for find_async operation");
}
int?userID = new Criteria <BOIdentityUserLogin>(IdentityUserLoginRepository)
.Add(Expression.Eq("LoginProvider", login.LoginProvider))
.Add(Expression.Eq("ProviderKey", login.ProviderKey))
.Add(new Projection("UserId"))
.List <IList <object> >()[0].Select((x) => (int?)x)
.SingleOrDefault();
TUser user = null;
if (userID.HasValue)
{
var identityUser = new BOIdentityUser();
identityUser.Repository = IdentityUserRepository;
identityUser.Init((int)userID);
user = LoadData(identityUser);
}
return(Task.FromResult(user));
}
public async Task <IHttpActionResult> DeleteIdentityUser(Int32 id)
{
var result = Task.Factory.StartNew(() =>
{
IUnitOfWork uow = new UnitOfWorkImp(new IRepositoryConnection[] { IdentityUserRepository });
var bo = new BOIdentityUser();
bo.Repository = IdentityUserRepository;
bo.Init(id);
uow.Delete(bo);
string err;
if (!uow.Commit(out err))
{
var resp = new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(err)
};
throw new HttpResponseException(resp);
}
return(true);
});
await result;
if (!result.Result)
{
return(NotFound());
}
return(Ok(result.Result));
}
public Task DeleteAsync(TUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
var boIdentityUser = new BOIdentityUser();
boIdentityUser.Repository = IdentityUserRepository;
boIdentityUser.Init(user.Id);
boIdentityUser.Delete();
/*remove possible stale object*/
var cachedObject = _identityUsersCache.SingleOrDefault(x => x.UserId == boIdentityUser.UserId);
if (cachedObject != null)
{
_identityUsersCache.Remove(cachedObject);
}
return(Task.FromResult(true));
}
public Task UpdateAsync(TUser user)
{
if (user == null)
{
throw new ArgumentNullException("null parameter for update_async operation");
}
var updatedUser = new BOIdentityUser();
updatedUser.Repository = IdentityUserRepository;
updatedUser.IdentityUserClaimRepository = IdentityUserClaimRepository;
updatedUser.IdentityUserLoginRepository = IdentityUserLoginRepository;
updatedUser.IdentityUserRoleRepository = IdentityUserRoleRepository;
updatedUser.Init(user.Id);
updatedUser.Username = user.UserName;
updatedUser.PasswordHash = user.PasswordHash;
updatedUser.SecurityStamp = user.SecurityStamp;
updatedUser.Email = user.Email;
updatedUser.PhoneNumber = user.PhoneNumber;
updatedUser.EmailConfirmed = user.IsEmailConfirmed;
updatedUser.PhoneNumberConfirmed = user.IsPhoneNumberConfirmed;
updatedUser.AccessFailedCount = user.AccessFailedCount;
updatedUser.LockoutEnabled = user.LockoutEnabled;
updatedUser.LockoutEndDateUtc = (user.LockoutEndDate.UtcDateTime != DateTime.MinValue ? user.LockoutEndDate.UtcDateTime : updatedUser.LockoutEndDateUtc);
updatedUser.TwoFactorEnabled = user.TwoFactorAuthEnabled;
updatedUser.Update();
updatedUser.DeleteAllIdentityUserClaim();
updatedUser.DeleteAllIdentityUserLogin();
updatedUser.DeleteAllIdentityUserRole();
foreach (var role in user.Roles)
{
BOIdentityRole identityRole = new Criteria <BOIdentityRole>(IdentityRoleRepository).Add(Expression.Eq("Name", role))
.SingleOrDefault <BOIdentityRole>();
if (identityRole != null)
{
updatedUser.AddIdentityUserRole(new BOIdentityUserRole()
{
Repository = IdentityUserRoleRepository, RoleId = identityRole.Id
});
}
}
foreach (var claim in user.Claims)
{
updatedUser.AddIdentityUserClaim(new BOIdentityUserClaim()
{
Repository = IdentityUserClaimRepository, ClaimType = claim.ClaimType, ClaimValue = claim.ClaimValue
});
}
foreach (var login in user.Logins)
{
updatedUser.AddIdentityUserLogin(new BOIdentityUserLogin()
{
Repository = IdentityUserLoginRepository, LoginProvider = login.LoginProvider, ProviderKey = login.ProviderKey
});
}
/*remove possible stale object, an updated one will get picked up in findbyidasync method when required*/
var cachedObject = _identityUsersCache.SingleOrDefault(x => x.UserId == updatedUser.UserId);
if (cachedObject != null)
{
_identityUsersCache.Remove(cachedObject);
}
_identityUsersCache.Add(updatedUser);
return(Task.FromResult(true));
}
