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 <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 IBOIdentityUser BOIdentityUser(IIdentityUserRepository repo)
{
BOIdentityUser boIdentityUser = (BOIdentityUser)BOIdentityUser();
boIdentityUser.Repository = repo;
return(boIdentityUser);
}
public Task CreateAsync(TUser user)
{
if (user == null)
{
throw new ArgumentNullException("user");
}
var newUser = new BOIdentityUser();
newUser.Repository = IdentityUserRepository;
newUser.Username = user.UserName;
newUser.PasswordHash = user.PasswordHash;
newUser.SecurityStamp = user.SecurityStamp;
newUser.Email = user.Email;
newUser.PhoneNumber = user.PhoneNumber;
newUser.EmailConfirmed = user.IsEmailConfirmed;
newUser.PhoneNumberConfirmed = user.IsPhoneNumberConfirmed;
newUser.AccessFailedCount = user.AccessFailedCount;
newUser.LockoutEnabled = user.LockoutEnabled;
newUser.LockoutEndDateUtc = (user.LockoutEndDate.UtcDateTime != DateTime.MinValue ? user.LockoutEndDate.UtcDateTime : newUser.LockoutEndDateUtc);
newUser.TwoFactorEnabled = user.TwoFactorAuthEnabled;
newUser.SaveNew();
foreach (var role in user.Roles)
{
BOIdentityRole identityRole = new Criteria <BOIdentityRole>(IdentityRoleRepository).Add(Expression.Eq("Name", role))
.SingleOrDefault <BOIdentityRole>();
if (identityRole != null)
{
newUser.AddIdentityUserRole(new BOIdentityUserRole()
{
Repository = IdentityUserRoleRepository, RoleId = identityRole.Id
});
}
}
foreach (var claim in user.Claims)
{
newUser.AddIdentityUserClaim(new BOIdentityUserClaim()
{
Repository = IdentityUserClaimRepository, ClaimType = claim.ClaimType, ClaimValue = claim.ClaimValue
});
}
foreach (var login in user.Logins)
{
newUser.AddIdentityUserLogin(new BOIdentityUserLogin()
{
Repository = IdentityUserLoginRepository, LoginProvider = login.LoginProvider, ProviderKey = login.ProviderKey
});
}
user.Id = (int)newUser.UserId;
_identityUsersCache.Add(newUser);
return(Task.FromResult(true));
}
public Task <TUser> FindByIdAsync(int userID)
{
var boIdentityUser = _identityUsersCache.SingleOrDefault(x => x.UserId == userID);
if (boIdentityUser == null)
{
boIdentityUser = new BOIdentityUser();
((BOIdentityUser)boIdentityUser).Repository = IdentityUserRepository;
((BOIdentityUser)boIdentityUser).Init(userID);
_identityUsersCache.Add(boIdentityUser);
}
return(Task.FromResult(LoadData(boIdentityUser)));
}
public IBOIdentityUser BOIdentityUser()
{
var boIdentityUser = new BOIdentityUser()
{
UserId = this.UserId,
Email = this.Email,
EmailConfirmed = this.EmailConfirmed,
PasswordHash = this.PasswordHash,
SecurityStamp = this.SecurityStamp,
PhoneNumber = this.PhoneNumber,
PhoneNumberConfirmed = this.PhoneNumberConfirmed,
TwoFactorEnabled = this.TwoFactorEnabled,
LockoutEndDateUtc = this.LockoutEndDateUtc,
LockoutEnabled = this.LockoutEnabled,
AccessFailedCount = this.AccessFailedCount,
Username = this.Username
};
return(boIdentityUser);
}
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));
}
