public void DesactivateUser(string userName)
{
Logger.LogInformation($"Try to desactivate user {userName}");
using (var c = RepositoriesFactory.CreateContext())
{
var repo = RepositoriesFactory.GetUserRepository(c);
var user = repo.GetByUserName(userName);
var local = this.GetErrorStringLocalizer();
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(local["DeleteUserNoUserFound"]);
}
user.IsValid = false;
repo.Update(user);
var ucRepo = RepositoriesFactory.GetUserClientRepository(c);
foreach (var uc in ucRepo.GetAllByCriterias(user.UserName, null, null, null, 0, Int32.MaxValue))
{
uc.RefreshToken = String.Empty;
ucRepo.Update(uc);
}
c.Commit();
}
}
private string GenerateAndSaveCode(string clientPublicId, string userName, string scope)
{
var codeValue = RandomService.GenerateRandomString(CodeLenght);
using (var context = RepositoriesFactory.CreateContext())
{
var userClientRepo = RepositoriesFactory.GetUserClientRepository(context);
var codeRepo = RepositoriesFactory.GetCodeRepository(context);
var uc = userClientRepo.GetUserClientByClientPublicIdAndUserName(clientPublicId, userName);
codeRepo.Add(new Domain.Code()
{
CodeValue = codeValue,
ExpirationTimeStamp = new DateTimeOffset(DateTime.Now.AddSeconds(Configuration.CodeDurationInSeconds)).ToUnixTimeSeconds(),
IsValid = true,
Scope = scope,
UserClientId = uc.Id
});
context.Commit();
}
return(codeValue);
}
public void DeleteReturnUrl(DeleteReturnUrlDto toDelete)
{
this.Validate(toDelete);
var resource = this.GetErrorStringLocalizer();
using (var context = RepositoriesFactory.CreateContext())
{
var returnUrlRepo = RepositoriesFactory.GetClientReturnUrlRepository(context);
var myReturnUrl = returnUrlRepo.GetById(toDelete.IdReturnUrl);
if (myReturnUrl == null)
{
throw new DaOAuthServiceException(resource["DeleteReturnUrlUnknowReturnUrl"]);
}
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByUserName(toDelete.UserName);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(resource["DeleteReturnUrlInvalidUser"]);
}
var ucRepo = RepositoriesFactory.GetUserClientRepository(context);
var uc = ucRepo.GetUserClientByClientPublicIdAndUserName(myReturnUrl.Client.PublicId, toDelete.UserName);
if (uc == null)
{
throw new DaOAuthServiceException(resource["DeleteReturnUrlBadUserNameOrClientId"]);
}
returnUrlRepo.Delete(myReturnUrl);
context.Commit();
}
}
public void SendMailLostPassword(LostPasswordDto infos)
{
Logger.LogInformation($"Send a mail password lost to {infos.Email}");
Validate(infos);
using (var context = RepositoriesFactory.CreateContext())
{
var errorResource = this.GetErrorStringLocalizer();
var mailResource = this.GetMailStringLocalizer();
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByEmail(infos.Email);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(errorResource["SendMailLostPasswordUserNoUserFound"]);
}
var myToken = JwtService.GenerateMailToken(user.UserName);
var link = new Uri(String.Format(Configuration.GetNewPasswordPageUrl, myToken.Token));
MailService.SendEmail(new SendEmailDto()
{
Body = String.Format(mailResource["MailLostPasswordBody"], link.AbsoluteUri),
IsHtml = true,
Receviers = new Dictionary <string, string>()
{
{ user.EMail, user.EMail }
},
Sender = new KeyValuePair <string, string>("*****@*****.**", "no reply"),
Subject = mailResource["MailLostPasswordSubject"]
});
}
}
public ClientDto GetById(int id, string userName)
{
Logger.LogInformation(String.Format("Try to get client by id {0}", id));
ClientDto toReturn = null;
using (var context = RepositoriesFactory.CreateContext())
{
var clientRepo = RepositoriesFactory.GetClientRepository(context);
var client = clientRepo.GetById(id);
if (client == null || !client.IsValid)
{
throw new DaOAuthNotFoundException();
}
// we need to remove scopes from invalid ressources servers
if (client.ClientsScopes != null && client.ClientsScopes.Count() > 0)
{
var invalidsRs = ExtractInvalidRessourceServerIds(context);
client.ClientsScopes = client.ClientsScopes.ToList().Where(cs => !invalidsRs.Contains(cs.Scope.RessourceServerId)).ToList();
}
toReturn = client.ToDto(client.UserCreator.UserName.Equals(userName));
}
return(toReturn);
}
private bool CheckIfUserHasAuthorizeOrDeniedClientAccess(string clientPublicId, string userName)
{
using (var context = RepositoriesFactory.CreateContext())
{
var clientUserRepo = RepositoriesFactory.GetUserClientRepository(context);
return(clientUserRepo.GetUserClientByClientPublicIdAndUserName(clientPublicId, userName) != null);
}
}
private TokenInfoDto GenerateTokenForRefreshToken(AskTokenDto tokenInfo, IStringLocalizer errorLocal)
{
TokenInfoDto toReturn = null;
if (String.IsNullOrWhiteSpace(tokenInfo.ClientPublicId))
{
throw new DaOAuthTokenException()
{
Error = OAuthConvention.ErrorNameRefreshToken,
Description = errorLocal["RefreshTokenParameterError"]
};
}
using (var context = RepositoriesFactory.CreateContext())
{
var clientRepo = RepositoriesFactory.GetClientRepository(context);
var myClient = clientRepo.GetByPublicId(tokenInfo.ClientPublicId);
if (!CheckIfClientsCredentialsAreValid(myClient, tokenInfo.AuthorizationHeader))
{
throw new DaOAuthTokenException()
{
Error = OAuthConvention.ErrorNameUnauthorizedClient,
Description = errorLocal["UnauthorizedClient"]
};
}
var tokenDetail = JwtService.ExtractToken(new ExtractTokenDto()
{
Token = tokenInfo.RefreshToken,
TokenName = OAuthConvention.RefreshToken
});
if (!CheckIfTokenIsValid(tokenDetail, context))
{
throw new DaOAuthTokenException()
{
Error = OAuthConvention.ErrorNameInvalidGrant,
Description = errorLocal["RefreshTokenInvalid"]
};
}
if (!CheckIfScopesAreAuthorizedForClient(tokenDetail.ClientId, tokenInfo.Scope))
{
throw new DaOAuthTokenException()
{
Error = OAuthConvention.ErrorNameInvalidScope,
Description = errorLocal["UnauthorizedScope"]
};
}
toReturn = GenerateAccessTokenAndUpdateRefreshToken(tokenInfo, context, tokenDetail.UserName);
context.Commit();
}
return(toReturn);
}
private bool CheckIfUserHasAuthorizeClient(string clientPublicId, string userName)
{
using (var context = RepositoriesFactory.CreateContext())
{
var clientUserRepo = RepositoriesFactory.GetUserClientRepository(context);
var uc = clientUserRepo.GetUserClientByClientPublicIdAndUserName(clientPublicId, userName);
return(uc != null && uc.IsActif);
}
}
public int CreateReturnUrl(CreateReturnUrlDto toCreate)
{
this.Validate(toCreate);
var idCreated = 0;
var resource = this.GetErrorStringLocalizer();
if (!Uri.TryCreate(toCreate.ReturnUrl, UriKind.Absolute, out var u))
{
throw new DaOAuthServiceException(resource["CreateReturnUrlReturnUrlIncorrect"]);
}
using (var context = RepositoriesFactory.CreateContext())
{
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByUserName(toCreate.UserName);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(resource["CreateReturnUrlInvalidUser"]);
}
var ucRepo = RepositoriesFactory.GetUserClientRepository(context);
var uc = ucRepo.GetUserClientByClientPublicIdAndUserName(toCreate.ClientPublicId, toCreate.UserName);
if (uc == null)
{
throw new DaOAuthServiceException(resource["CreateReturnUrlBadUserNameOrClientId"]);
}
var clientRepo = RepositoriesFactory.GetClientRepository(context);
var client = clientRepo.GetByPublicId(toCreate.ClientPublicId);
if (client == null || !client.IsValid)
{
throw new DaOAuthServiceException(resource["CreateReturnUrlInvalidClient"]);
}
var existingReturnUrl = client.ClientReturnUrls.FirstOrDefault(c => c.ReturnUrl.Equals(toCreate.ReturnUrl, StringComparison.OrdinalIgnoreCase));
if (existingReturnUrl != null)
{
idCreated = existingReturnUrl.Id;
}
else
{
var returnUrlRepo = RepositoriesFactory.GetClientReturnUrlRepository(context);
idCreated = returnUrlRepo.Add(new Domain.ClientReturnUrl()
{
ClientId = client.Id,
ReturnUrl = toCreate.ReturnUrl
});
}
context.Commit();
}
return(idCreated);
}
public void Delete(DeleteClientDto toDelete)
{
Logger.LogInformation(String.Format("Try to create delete by user {0}", toDelete != null ? toDelete.UserName : String.Empty));
Validate(toDelete);
using (var context = RepositoriesFactory.CreateContext())
{
var clientRepo = RepositoriesFactory.GetClientRepository(context);
var userClientRepo = RepositoriesFactory.GetUserClientRepository(context);
var userRepo = RepositoriesFactory.GetUserRepository(context);
var clientScopeRepo = RepositoriesFactory.GetClientScopeRepository(context);
var clientReturnUrlRepo = RepositoriesFactory.GetClientReturnUrlRepository(context);
var myUser = userRepo.GetByUserName(toDelete.UserName);
if (myUser == null || !myUser.IsValid)
{
throw new DaOAuthServiceException("DeleteClientInvalidUserName");
}
var myClient = clientRepo.GetById(toDelete.Id);
if (myClient == null)
{
throw new DaOAuthServiceException("DeleteClientUnknowClient");
}
var myUserClient = userClientRepo
.GetUserClientByClientPublicIdAndUserName(myClient.PublicId, toDelete.UserName);
if (myUserClient == null || !myUserClient.Client.UserCreator.UserName.Equals(toDelete.UserName, StringComparison.OrdinalIgnoreCase))
{
throw new DaOAuthServiceException("DeleteClientWrongUser");
}
foreach (var cr in clientReturnUrlRepo.GetAllByClientPublicId(myClient.PublicId).ToList())
{
clientReturnUrlRepo.Delete(cr);
}
foreach (var cs in clientScopeRepo.GetAllByClientId(myClient.Id).ToList())
{
clientScopeRepo.Delete(cs);
}
foreach (var uc in userClientRepo.GetAllByClientId(myClient.Id).ToList())
{
userClientRepo.Delete(uc);
}
userClientRepo.Delete(myUserClient);
clientRepo.Delete(myClient);
context.Commit();
}
}
public int SearchCount(AdminUserSearchDto criterias)
{
Validate(criterias, ExtendValidationSearchCriterias);
using (var c = RepositoriesFactory.CreateContext())
{
var userRepo = RepositoriesFactory.GetUserRepository(c);
return(userRepo.GetAllByCriteriasCount(criterias.UserName, criterias.Email, criterias.IsValid));
}
}
public int SearchCount(RessourceServerSearchDto criterias)
{
Validate(criterias, ExtendValidationSearchCriterias);
var count = 0;
using (var c = RepositoriesFactory.CreateContext())
{
var rsRepo = RepositoriesFactory.GetRessourceServerRepository(c);
count = rsRepo.GetAllByCriteriasCount(criterias.Name, criterias.Login, true);
}
return(count);
}
public int SearchCount(UserClientSearchDto criterias)
{
Validate(criterias, ExtendValidationSearchCriterias);
var count = 0;
using (var c = RepositoriesFactory.CreateContext())
{
var userClientRepo = RepositoriesFactory.GetUserClientRepository(c);
count = userClientRepo.GetAllByCriteriasCount(criterias.UserName, criterias.Name, true, GetClientTypeId(criterias.ClientType));
}
return(count);
}
public IEnumerable <ScopeDto> GetAll()
{
using (var context = RepositoriesFactory.CreateContext())
{
var scopes = new List <Scope>();
var rsRepo = RepositoriesFactory.GetRessourceServerRepository(context);
var scopeRepo = RepositoriesFactory.GetScopeRepository(context);
var validRs = rsRepo.GetAll().Where(rs => rs.IsValid.Equals(true)).Select(rs => rs.Id).ToList();
scopes = scopeRepo.GetAll().Where(s => validRs.Contains(s.RessourceServerId)).ToList();
return(scopes.ToDto());
}
}
public void DeleteUser(string userName)
{
Logger.LogInformation($"delete user {userName}");
using (var context = RepositoriesFactory.CreateContext())
{
var userRepository = RepositoriesFactory.GetUserRepository(context);
var clientRepository = RepositoriesFactory.GetClientRepository(context);
var userClientRepository = RepositoriesFactory.GetUserClientRepository(context);
var user = userRepository.GetByUserName(userName);
var local = this.GetErrorStringLocalizer();
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(local["DeleteUserNoUserFound"]);
}
var clients = clientRepository.GetAllClientsByIdCreator(user.Id);
IList <Client> toDeleteClients = new List <Client>();
IList <UserClient> toDeleteUsersClients = new List <UserClient>();
foreach (var client in clients)
{
foreach (var uc in userClientRepository.GetAllByClientId(client.Id))
{
toDeleteUsersClients.Add(uc);
}
toDeleteClients.Add(client);
}
foreach (var uc in toDeleteUsersClients)
{
userClientRepository.Delete(uc);
}
foreach (var c in toDeleteClients)
{
clientRepository.Delete(c);
}
userRepository.Delete(user);
context.Commit();
}
}
public AdminUserDetailDto GetByIdUser(int idUser)
{
using (var context = RepositoriesFactory.CreateContext())
{
var userClientRepo = RepositoriesFactory.GetUserRepository(context);
var user = userClientRepo.GetById(idUser);
if (user == null)
{
throw new DaOAuthNotFoundException("GetByIdUserUserNotFound");
}
return(user.ToAdminDetailDto());
}
}
private TokenInfoDto GenerateTokenForClientCredentailsGrant(AskTokenDto tokenInfo, IStringLocalizer errorLocal)
{
TokenInfoDto toReturn = null;
using (var context = RepositoriesFactory.CreateContext())
{
var clientRepo = RepositoriesFactory.GetClientRepository(context);
var myClient = clientRepo.GetByPublicId(tokenInfo.ClientPublicId);
if (!CheckIfClientsCredentialsAreValid(myClient, tokenInfo.AuthorizationHeader))
{
throw new DaOAuthTokenException()
{
Error = OAuthConvention.ErrorNameUnauthorizedClient,
Description = errorLocal["UnauthorizedClient"]
};
}
if (!CheckIfScopesAreAuthorizedForClient(myClient.PublicId, tokenInfo.Scope))
{
throw new DaOAuthTokenException()
{
Error = OAuthConvention.ErrorNameInvalidScope,
Description = errorLocal["UnauthorizedScope"]
};
}
var accesToken = JwtService.GenerateToken(new CreateTokenDto()
{
ClientPublicId = myClient.PublicId,
Scope = tokenInfo.Scope,
SecondsLifeTime = Configuration.AccesTokenLifeTimeInSeconds,
TokenName = OAuthConvention.AccessToken,
UserName = String.Empty
});
toReturn = new TokenInfoDto()
{
AccessToken = accesToken.Token,
ExpireIn = Configuration.AccesTokenLifeTimeInSeconds,
Scope = tokenInfo.Scope,
TokenType = OAuthConvention.AccessToken
};
}
return(toReturn);
}
public void UpdateUser(UpdateUserDto toUpdate)
{
IList <ValidationResult> ExtendValidation(UpdateUserDto toValidate)
{
var resource = this.GetErrorStringLocalizer();
IList <ValidationResult> result = new List <ValidationResult>();
using (var c = RepositoriesFactory.CreateContext())
{
var repo = RepositoriesFactory.GetUserRepository(c);
var user = repo.GetByUserName(toUpdate.UserName);
if (user == null || !user.IsValid)
{
result.Add(new ValidationResult(resource["UpdateUserNoUserFound"]));
}
var errorResource = this.GetErrorStringLocalizer();
var getByMailUser = repo.GetByEmail(toValidate.EMail);
if (getByMailUser != null && getByMailUser.Id != user.Id)
{
result.Add(new ValidationResult(String.Format(errorResource["CreateUserEmailExists"], toValidate.EMail)));
}
}
return(result);
}
Logger.LogInformation(String.Format("Try to update user {0}", toUpdate != null ? toUpdate.UserName : String.Empty));
Validate(toUpdate, ExtendValidation);
using (var c = RepositoriesFactory.CreateContext())
{
var repo = RepositoriesFactory.GetUserRepository(c);
var user = repo.GetByUserName(toUpdate.UserName);
user.BirthDate = toUpdate.BirthDate;
user.EMail = toUpdate.EMail;
user.FullName = toUpdate.FullName;
repo.Update(user);
c.Commit();
}
}
public int CreateUserClient(CreateUserClientDto toCreate)
{
Validate(toCreate);
var id = 0;
var local = GetErrorStringLocalizer();
using (var context = RepositoriesFactory.CreateContext())
{
var userClientRepo = RepositoriesFactory.GetUserClientRepository(context);
var clientRepo = RepositoriesFactory.GetClientRepository(context);
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByUserName(toCreate.UserName);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(local["CreateUserClientInvalidUserName"]);
}
var client = clientRepo.GetByPublicId(toCreate.ClientPublicId);
if (client == null || !client.IsValid)
{
throw new DaOAuthServiceException(local["CreateUserClientInvalidClientPublicId"]);
}
var uc = userClientRepo.GetUserClientByClientPublicIdAndUserName(toCreate.ClientPublicId, toCreate.UserName);
if (uc != null)
{
throw new DaOAuthServiceException(local["CreateUserClientClientAlreadyRegister"]);
}
id = userClientRepo.Add(new UserClient()
{
ClientId = client.Id,
CreationDate = DateTime.Now,
IsActif = toCreate.IsActif,
UserId = user.Id
});
context.Commit();
}
return(id);
}
public IEnumerable <UserClientListDto> Search(UserClientSearchDto criterias)
{
Validate(criterias, ExtendValidationSearchCriterias);
IList <UserClient> clients = null;
var clientTypeId = GetClientTypeId(criterias.ClientType);
using (var context = RepositoriesFactory.CreateContext())
{
var clientRepo = RepositoriesFactory.GetUserClientRepository(context);
clients = clientRepo.GetAllByCriterias(criterias.UserName, criterias.Name,
true, clientTypeId, criterias.Skip, criterias.Limit).ToList();
}
return(clients != null?clients.ToDto(criterias.UserName) : new List <UserClientListDto>());
}
public IEnumerable <RessourceServerDto> Search(RessourceServerSearchDto criterias)
{
Logger.LogInformation("Search ressource servers");
Validate(criterias, ExtendValidationSearchCriterias);
IList <RessourceServer> rs = null;
using (var context = RepositoriesFactory.CreateContext())
{
var rsRepo = RepositoriesFactory.GetRessourceServerRepository(context);
rs = rsRepo.GetAllByCriterias(criterias.Name, criterias.Login, true, criterias.Skip, criterias.Limit).ToList();
}
return(rs != null?rs.ToDto() : new List <RessourceServerDto>());
}
public void Delete(DeleteRessourceServerDto toDelete)
{
Logger.LogInformation(String.Format("Try to delete ressource server for user {0}", toDelete != null ? toDelete.UserName : String.Empty));
Validate(toDelete);
using (var context = RepositoriesFactory.CreateContext())
{
var userRepo = RepositoriesFactory.GetUserRepository(context);
var rsRepo = RepositoriesFactory.GetRessourceServerRepository(context);
var scopeRepo = RepositoriesFactory.GetScopeRepository(context);
var clientScopeRepo = RepositoriesFactory.GetClientScopeRepository(context);
var myUser = userRepo.GetByUserName(toDelete.UserName);
if (myUser == null || !myUser.IsValid)
{
throw new DaOAuthServiceException("DeleteRessourceServerInvalidUserName");
}
if (myUser.UsersRoles.FirstOrDefault(r => r.RoleId.Equals((int)ERole.ADMIN)) == null)
{
throw new DaOAuthServiceException("DeleteRessourceServerNonAdminUserName");
}
var myRs = rsRepo.GetById(toDelete.Id);
if (myRs == null)
{
throw new DaOAuthServiceException("DeleteRessourceServerRessourceServerNotFound");
}
foreach (var s in myRs.Scopes.ToList())
{
foreach (var cs in clientScopeRepo.GetAllByScopeId(s.Id).ToList())
{
clientScopeRepo.Delete(cs);
}
scopeRepo.Delete(s);
}
rsRepo.Delete(myRs);
context.Commit();
}
}
public UserDto GetUser(string userName)
{
Logger.LogInformation($"Try get user {userName}");
UserDto result = null;
using (var c = RepositoriesFactory.CreateContext())
{
var repo = RepositoriesFactory.GetUserRepository(c);
var user = repo.GetByUserName(userName);
if (user != null && user.IsValid)
{
result = user.ToDto();
}
}
return(result);
}
public void UpdateReturnUrl(UpdateReturnUrlDto toUpdate)
{
this.Validate(toUpdate);
var resource = this.GetErrorStringLocalizer();
if (!Uri.TryCreate(toUpdate.ReturnUrl, UriKind.Absolute, out var u))
{
throw new DaOAuthServiceException(resource["UpdateReturnUrlReturnUrlIncorrect"]);
}
using (var context = RepositoriesFactory.CreateContext())
{
var returnUrlRepo = RepositoriesFactory.GetClientReturnUrlRepository(context);
var myReturnUrl = returnUrlRepo.GetById(toUpdate.IdReturnUrl);
if (myReturnUrl == null)
{
throw new DaOAuthServiceException(resource["UpdateReturnUrlUnknowReturnUrl"]);
}
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByUserName(toUpdate.UserName);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(resource["UpdateReturnUrlInvalidUser"]);
}
var ucRepo = RepositoriesFactory.GetUserClientRepository(context);
var uc = ucRepo.GetUserClientByClientPublicIdAndUserName(myReturnUrl.Client.PublicId, toUpdate.UserName);
if (uc == null)
{
throw new DaOAuthServiceException(resource["UpdateReturnUrlBadUserNameOrClientId"]);
}
myReturnUrl.ReturnUrl = toUpdate.ReturnUrl;
returnUrlRepo.Update(myReturnUrl);
context.Commit();
}
}
public void UpdateUserClient(UpdateUserClientDto toUpdate)
{
IList <ValidationResult> ExtendValidation(UpdateUserClientDto toValidate)
{
var resource = this.GetErrorStringLocalizer();
IList <ValidationResult> result = new List <ValidationResult>();
using (var context = RepositoriesFactory.CreateContext())
{
var ucRepo = RepositoriesFactory.GetUserClientRepository(context);
var myUc = ucRepo.GetUserClientByClientPublicIdAndUserName(toValidate.ClientPublicId, toValidate.UserName);
if (myUc == null)
{
result.Add(new ValidationResult(resource["UpdateUserClientUserOrClientNotFound"]));
}
if (myUc != null && (myUc.User == null || !myUc.User.IsValid))
{
result.Add(new ValidationResult(resource["UpdateUserClientUserNotValid"]));
}
if (myUc != null && (myUc.Client == null || !myUc.Client.IsValid))
{
result.Add(new ValidationResult(resource["UpdateUserClientClientNotValid"]));
}
}
return(result);
}
this.Validate(toUpdate, ExtendValidation);
using (var context = RepositoriesFactory.CreateContext())
{
var ucRepo = RepositoriesFactory.GetUserClientRepository(context);
var myUc = ucRepo.GetUserClientByClientPublicIdAndUserName(toUpdate.ClientPublicId, toUpdate.UserName);
myUc.IsActif = toUpdate.IsActif;
ucRepo.Update(myUc);
context.Commit();
}
}
public void ChangeUserPassword(ChangePasswordDto infos)
{
Logger.LogInformation($"Change password from user {infos.UserName}");
Validate(infos);
using (var context = RepositoriesFactory.CreateContext())
{
var local = this.GetErrorStringLocalizer();
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByUserName(infos.UserName);
if (user == null || !user.IsValid)
{
throw new DaOAuthServiceException(local["ChangeUserPasswordUserInvalid"]);
}
if (!EncryptionService.AreEqualsSha256(
String.Concat(Configuration.PasswordSalt, infos.OldPassword), user.Password))
{
throw new DaOAuthServiceException(local["ChangeUserPasswordPasswordInvalid"]);
}
if (!infos.NewPassword.Equals(infos.NewPasswordRepeat, StringComparison.Ordinal))
{
throw new DaOAuthServiceException(local["ChangeUserPasswordDifferentsNewPasswords"]);
}
if (!infos.NewPassword.IsMatchPasswordPolicy())
{
throw new DaOAuthServiceException(local["ChangeUserPasswordNewPasswordDontMatchPolicy"]);
}
user.Password = EncryptionService.Sha256Hash(String.Concat(Configuration.PasswordSalt, infos.NewPassword));
userRepo.Update(user);
context.Commit();
}
}
public IEnumerable <AdminUsrDto> Search(AdminUserSearchDto criterias)
{
Validate(criterias, ExtendValidationSearchCriterias);
IList <User> users = null;
using (var context = RepositoriesFactory.CreateContext())
{
var userRepo = RepositoriesFactory.GetUserRepository(context);
users = userRepo.GetAllByCriterias(criterias.UserName, criterias.Email, criterias.IsValid,
criterias.Skip, criterias.Limit).ToList();
}
if (users != null)
{
return(users.ToAdminDto());
}
return(new List <AdminUsrDto>());
}
public void ActivateUser(string userName)
{
Logger.LogInformation($"Try to activate user {userName}");
using (var c = RepositoriesFactory.CreateContext())
{
var repo = RepositoriesFactory.GetUserRepository(c);
var user = repo.GetByUserName(userName);
var local = this.GetErrorStringLocalizer();
if (user == null || user.IsValid)
{
throw new DaOAuthServiceException(local["DeleteUserNoUserFound"]);
}
user.IsValid = true;
repo.Update(user);
c.Commit();
}
}
public RessourceServerDto GetById(int id)
{
Logger.LogInformation(String.Format("Try to get ressource server by id {0}", id));
RessourceServerDto toReturn = null;
using (var context = RepositoriesFactory.CreateContext())
{
var rsRepo = RepositoriesFactory.GetRessourceServerRepository(context);
var rs = rsRepo.GetById(id);
if (rs == null || !rs.IsValid)
{
throw new DaOAuthNotFoundException();
}
toReturn = rs.ToDto();
}
return(toReturn);
}
private IList <ValidationResult> ExtendValidationSearchCriterias(UserClientSearchDto c)
{
var resource = this.GetErrorStringLocalizer();
IList <ValidationResult> result = new List <ValidationResult>();
using (var context = RepositoriesFactory.CreateContext())
{
var userRepo = RepositoriesFactory.GetUserRepository(context);
var user = userRepo.GetByUserName(c.UserName);
if (user == null || !user.IsValid)
{
result.Add(new ValidationResult(String.Format(resource["SearchClientInvalidUser"], c)));
}
}
if (c.Limit - c.Skip > 50)
{
result.Add(new ValidationResult(String.Format(resource["SearchClientAskTooMuch"], c)));
}
return(result);
}
