public void Should_not_have_error_when_invalid_model_is_supplied()
{
Client model = new Client
{
FirstName = "Rodrigo",
LastName = "Campero",
Email = "*****@*****.**",
Gender = Gender.Male,
Phone = "(11) 96447-7215"
};
FluentValidation.Results.ValidationResult validateResult = validator.Validate(model);
Assert.IsTrue(!validateResult.Errors.Any());
}
private bool ClientValidator(Client client)
{
var clientValidator = new ClientValidator();
client.ValidationResult = clientValidator.Validate(client);
return(client.ValidationResult.Errors.Any());
}
public async Task <Result> UpdateClient(ScopeOptions scope, ClientEdit client)
{
var validator = new ClientValidator(_context, scope, false);
var result = validator.Validate(client, ruleSet: "default,availability").GetResult();
if (!result.Success)
{
return(result);
}
var entity = await GetClientEntityQuery(scope).FirstOrDefaultAsync(m => m.Id == client.Id);
if (entity == null)
{
return(new Result());
}
var clientEntity = MapModelToEntity(client, entity);
await _context.SaveChangesAsync();
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "Client", entity.Id, client);
return(result);
}
private bool ValidatorClient(Client client)
{
var clientValidator = new ClientValidator();
var result = clientValidator.Validate(client);
return(result.IsValid);
}
/// <summary>
/// Validate the parameters information
/// </summary>
private string Validate(Client input, bool IsUpdate = false)
{
var modelValidator = new ClientValidator(IsUpdate);
var validationResult = modelValidator.Validate(input);
return(validationResult.GetMessage());
}
public override Result <bool> ValidateEntity(Client entity)
{
var validator = new ClientValidator();
var result = validator.Validate(entity);
return(new Result <bool>(result.IsValid, true));
}
public void IsValid_should_check_doublon()
{
var client = new Client
{
Id = Guid.NewGuid().ToString(),
ProtocolType = "oidc",
AllowedGrantTypes = new List <ClientGrantType>
{
new ClientGrantType
{
GrantType = "custom"
}
},
AllowedScopes = new List <ClientScope>(),
RedirectUris = new List <ClientUri>
{
new ClientUri
{
Uri = "https://exemple.com"
},
new ClientUri
{
Uri = "https://exemple.com"
}
},
Properties = new List <ClientProperty>(),
Resources = new List <ClientLocalizedResource>()
};
var localizerMock = new Mock <IStringLocalizer>();
localizerMock.SetupGet(m => m[It.IsAny <string>()]).Returns(new LocalizedString(Guid.NewGuid().ToString(), Guid.NewGuid().ToString()));
var validator = new ClientValidator(client, localizerMock.Object);
var result = validator.Validate(client);
Assert.Equal(2, result.Errors.Count);
client.RedirectUris.Remove(client.RedirectUris.First());
result = validator.Validate(client);
Assert.Empty(result.Errors);
}
public static bool RunValidator(ClientValidator validatorClient, Client client)
{
var validator = validatorClient.Validate(client);
if (validator.IsValid)
{
return(true);
}
return(false);
}
public void Clients_AreAllValid()
{
_mockEnv.Setup(m => m.Get(It.IsAny <string>())).Returns(null as string);
var manager = new ClientManager(_mockEnv.Object);
var clients = manager.Clients;
var validator = new ClientValidator();
manager.Clients.ForEach(c => validator.Validate(c).IsValid.Should().BeTrue());
}
public override bool IsValid()
{
var validator = new ClientValidator();
var result = validator.Validate(this);
foreach (var item in result.Errors)
{
this.Errors.Add(item);
}
return(result.IsValid);
}
public async Task <Response> Insert(ClientDTO client)
{
Response response = new Response();
ClientValidator validate = new ClientValidator();
ValidationResult result = validate.Validate(client);
Response password = PasswordValidator.CheckPassword(client.Password, client.BirthDate);
//Verifica se a senha está dentro dos padrões, caso esteja, hasheia e ela
if (password.HasErrors())
{
response.Errors.Add(password.Errors.ToString());
}
else
{
client.Password = HashUtils.HashPassword(client.Password);
}
if (!result.IsValid)
{
foreach (var failure in result.Errors)
{
//Caso haja erros no validator, serão adicionados na response.Errors do client
response.Errors.Add("Property " + failure.PropertyName + " failed validation. Error was: " + "(" + failure.ErrorMessage + ")");
}
return(response);
}
if (response.HasErrors())
{
return(response);
}
else
{
try
{
client.AccessLevel = DataTransferObject.Enums.EAccessLevel.Client;
client.SystemEntranceDate = DateTime.Now;
client.IsActive = true;
return(response = await _iClientRepository.Insert(client));
}
catch (Exception ex)
{
_log.Error(ex + "\nStackTrace: " + ex.StackTrace);
response.Errors.Add("DataBase error, contact the system owner");
return(response);
}
}
}
public void Validate_WhenValid_HasNoErrors()
{
var client = new Client()
{
Name = "Get an Adviser",
Description = "A Rails application that enables candidates to sign up for a teacher training adviser.",
Role = "GetAnAdvisor",
ApiKeyPrefix = "GET_AN_ADVISOR",
};
var result = _validator.Validate(client);
result.IsValid.Should().BeTrue();
}
public async Task <Response> Update(ClientDTO client)
{
Response response = new Response();
ClientValidator validate = new ClientValidator();
ValidationResult result = validate.Validate(client);
Response password = PasswordValidator.CheckPassword(client.Password, client.BirthDate);
//Verifica se a senha está dentro dos padrões, caso esteja, hasheia e ela
if (password.HasErrors())
{
response.Errors.Add(password.Errors.ToString());
}
else
{
client.Password = HashUtils.HashPassword(client.Password);
}
if (!result.IsValid)
{
foreach (var failure in result.Errors)
{
response.Errors.Add("Property " + failure.PropertyName + " failed validation. Error was: " + "(" + failure.ErrorMessage + ")");
}
return(response);
}
if (response.HasErrors())
{
return(response);
}
else
{
try
{
return(response = await _iClientRepository.Update(client));
}
catch (Exception ex)
{
_log.Error(ex + "\nStackTrace: " + ex.StackTrace);
response.Errors.Add("DataBase error, contact the system owner");
return(response);
}
}
}
public IActionResult Register(Client client)
{
ValidationResult result = _validator.Validate(client);
if (!ModelState.IsValid)
{
var errors = ModelState.Values.SelectMany(x => x.Errors).Select(x => x.ErrorMessage).ToList();
return(BadRequest(errors));
}
if (!result.IsValid)
{
var validationErrors = result.Errors.Select(x => $"{x.PropertyName} failed validation: ${x.ErrorMessage}.");
return(BadRequest(string.Join(";", validationErrors)));
}
this._clientRepository.Create(client);
return(Ok());
}
public async Task <IActionResult> PostClient(Client client)
{
var validator = new ClientValidator();
var result = validator.Validate(client);
if (result.IsValid)
{
if (await _clientRepository.InsertClient(client))
{
return(Ok());
}
else
{
return(BadRequest());
}
}
else
{
//to do: Log error from result.Errors
return(BadRequest());
}
}
public async Task <Response> Insert(ClientDTO client)
{
Response response = new Response();
ClientValidator validate = new ClientValidator();
ValidationResult result = validate.Validate(client);
Response password = PasswordValidator.CheckPassword(client.Password, client.BirthDate);
//Verifica se a senha está dentro dos padrões, caso esteja, hasheia e ela
if (password.HasErrors())
{
response.Errors.Add(password.Errors.ToString());
}
else
{
client.Password = HashUtils.HashPassword(client.Password);
}
//result.MergeValidationErrors(response);
if (!result.IsValid)
{
foreach (var failure in result.Errors)
{
response.Errors.Add("Property " + failure.PropertyName + " failed validation. Error was: " + "(" + failure.ErrorMessage + ")");
}
return(response);
}
if (response.HasErrors())
{
return(response);
}
else
{
return(await _iClientRepository.Insert(client));
}
}
public async Task <Result> InsertClient(ScopeOptions scope, ClientEdit client)
{
var validator = new ClientValidator(_context, scope, true);
var result = validator.Validate(client, ruleSet: "default,availability").GetResult();
if (!result.Success)
{
return(result);
}
var entity = MapModelToEntity(client);
entity.OrganisationId = scope.OrganisationId;
await _context.Client.AddAsync(entity);
await _context.SaveChangesAsync();
client.Id = entity.Id;
result.Tag = client;
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_INSERT, "Client", entity.Id, client);
return(result);
}
public OperationResponse <CaseDto> Post(CreateCase request)
{
OperationResponse <CaseDto> operationResponse = new OperationResponse <CaseDto>();
ClientValidator clientValidator = new ClientValidator();
CaseInformationValidator caseInformationValidator = new CaseInformationValidator();
NotesValidator notesValidator = new NotesValidator();
CaseInformationDto caseInformation = request.CaseDto.CaseInformation;
ClientDto client = request.CaseDto.Client;
NotesDto notes = request.CaseDto.Notes;
CaseStatusDto caseStatus = request.CaseDto.CaseStatus;
List <CaseReferenceDto> references = request.CaseDto.References;
List <string> errors = new List <string>();
ValidationResult validationResult = clientValidator.Validate(client);
if (!validationResult.IsValid)
{
;
foreach (var error in validationResult.Errors)
{
errors.Add(error.ErrorMessage);
}
}
validationResult = caseInformationValidator.Validate(caseInformation);
if (!validationResult.IsValid)
{
foreach (var error in validationResult.Errors)
{
errors.Add(error.ErrorMessage);
}
}
validationResult = notesValidator.Validate(notes);
if (!validationResult.IsValid)
{
foreach (var error in validationResult.Errors)
{
errors.Add(error.ErrorMessage);
}
}
if (errors.Count != 0)
{
operationResponse.OnError("Invalid input data", errors);
return(operationResponse);
}
try
{
CaseDto caseDto = CaseBusinessLogic.AddNewCase(client, caseInformation, notes, caseStatus, references);
operationResponse.OnSuccess(caseDto, "Added successfully");
return(operationResponse);
}
catch (Exception e)
{
Log.Error(e.Message);
operationResponse.OnException(e.Message);
return(operationResponse);
}
}
public async Task <Result> MergeClients(ScopeOptions scope, MergeClients merge)
{
var clientValidator = new ClientValidator(_context, scope, true);
var result = clientValidator.Validate(merge.TargetClient, ruleSet: "default").GetResult();
if (!result.Success)
{
return(result);
}
var mergeValidator = new MergeClientsValidator(_context, scope);
result = mergeValidator.Validate(merge).GetResult();
if (!result.Success)
{
return(result);
}
var strategy = _context.Database.CreateExecutionStrategy();
result = await strategy.ExecuteAsync <Result>(async() =>
{
using (var transaction = _context.Database.BeginTransaction())
{
try
{
//Insert the 'new' client
var entity = MapModelToEntity(merge.TargetClient);
entity.OrganisationId = scope.OrganisationId;
await _context.Client.AddAsync(entity);
await _context.SaveChangesAsync();
merge.TargetClient.Id = entity.Id;
//Move dependancies to the new client -----------------------------------------------------
//1. Policies
var policies = await _context.Policy.Where(p => merge.SourceClientIds.Contains(p.ClientId)).ToListAsync();
foreach (var policy in policies)
{
policy.ClientId = merge.TargetClient.Id.Value;
}
//2. Contacts
var contacts = await _context.Contact.Where(c => merge.SourceClientIds.Contains(c.ClientId)).ToListAsync();
foreach (var contact in contacts)
{
contact.ClientId = merge.TargetClient.Id.Value;
}
//3. Commission Errors
var commissionErrors = await _context.CommissionError.Where(c => merge.SourceClientIds.Contains(c.ClientId.Value)).ToListAsync();
foreach (var commissionError in commissionErrors)
{
commissionError.ClientId = merge.TargetClient.Id.Value;
}
//4. To Commission Allocations
var toCommissionAllocations = await _context.CommissionAllocation.Where(c => merge.SourceClientIds.Contains(c.ToClientId)).ToListAsync();
foreach (var toCommissionAllocation in toCommissionAllocations)
{
toCommissionAllocation.ToClientId = merge.TargetClient.Id.Value;
}
//5. From Commission Allocations
var fromCommissionAllocations = await _context.CommissionAllocation.Where(c => merge.SourceClientIds.Contains(c.FromClientId)).ToListAsync();
foreach (var fromCommissionAllocation in fromCommissionAllocations)
{
fromCommissionAllocation.FromClientId = merge.TargetClient.Id.Value;
}
await _context.SaveChangesAsync();
//----------------------------------------------------------------------------------------
//Delete 'old' clients
var clientToDelete = await _context.Client.Where(m => merge.SourceClientIds.Contains(m.Id)).ToListAsync();
foreach (var client in clientToDelete)
{
client.IsDeleted = true;
}
await _context.SaveChangesAsync();
//Commit
await transaction.CommitAsync();
return(new Result(true));
}
catch
{
transaction.Rollback();
return(new Result(false));
}
}
});
result.Tag = merge.TargetClient;
await _auditService.InsertAuditLog(scope, "Merge", "Client", merge.TargetClient.Id, merge);
return(result);
}
// Cette méthode est utlisée lorsqu'on clique sur le bouton d'action
public string EffectuerAction(int index)
{
ClientValidator validator = new ClientValidator(client);
validator.Validate();
if (this.effectuer == "Effectuer la modification")
{
// met à jour la personne dans la base de données.
int resultat = this._accesBD.UpdateClient(client.ToMetier());
if (resultat != 0)
{
// Mise à jour de la liste des personnes affichée
collectionClients[index] = this.client;
// initialisation des champs de la personne
// à modifier ou à ajouter
this.Clear_personne();
this.Effectuer = "";
return("La modification s'est bien déroulée.");
}
return("La modification ne s'est pas bien déroulée.");
}
if (this.effectuer == "Effectuer l'ajout")
{
if (DoesExistInDB(client.NumPermisConduire))
{
throw new Exception("Ce numéro de permis existe déjà en DB.");
}
int resultat = this._accesBD.AjouterClient(client.ToMetier());
if (resultat != 0)
{
// Mise à jour de la liste des personnes affichée ordonné par nom et prénom
List <Client> listClients;
listClients = this._accesBD.ListClients();
collectionClients.Clear();
// prépare la liste des personnes à afficher
if (listClients != null)
{
while (listClients.Count > 0)
{
collectionClients.Add(new Client(listClients[0]).ToDto());
listClients.RemoveAt(0);
}
}
// Initialisation à vide des champs de la personne à modifier ou à ajouter
this.Clear_personne();
this.Effectuer = "";
return("L'ajout s'est bien déroulée.");
}
}
return("Action inconnue ");
}
public OperationResponse <CaseDto> Put(EditCase request)
{
OperationResponse <CaseDto> operationResponse = new OperationResponse <CaseDto>();
ClientValidator clientValidator = new ClientValidator();
CaseInformationValidator caseInformationValidator = new CaseInformationValidator();
NotesValidator notesValidator = new NotesValidator();
CaseInformationDto caseInformation = request.CaseDto.CaseInformation;
ClientDto client = request.CaseDto.Client;
NotesDto notes = request.CaseDto.Notes;
CaseStatusDto caseStatus = request.CaseDto.CaseStatus;
List <CaseReferenceDto> references = request.CaseDto.References;
ValidationResult validationResult = clientValidator.Validate(client);
if (!validationResult.IsValid)
{
List <string> errors = new List <string>();
foreach (var error in validationResult.Errors)
{
errors.Add(error.ErrorMessage);
}
operationResponse.OnError("Invalid client data", errors);
return(operationResponse);
}
validationResult = caseInformationValidator.Validate(caseInformation);
if (!validationResult.IsValid)
{
List <string> errors = new List <string>();
foreach (var error in validationResult.Errors)
{
errors.Add(error.ErrorMessage);
}
operationResponse.OnError("Invalid case-information data", errors);
return(operationResponse);
}
validationResult = notesValidator.Validate(notes);
if (!validationResult.IsValid)
{
List <string> errors = new List <string>();
foreach (var error in validationResult.Errors)
{
errors.Add(error.ErrorMessage);
}
operationResponse.OnError("Invalid case-information data", errors);
return(operationResponse);
}
try
{
CaseDto caseDto = this.CaseBusinessLogic.EditCase(client.CaseId, client, caseInformation, notes, caseStatus, references);
operationResponse.OnSuccess(caseDto, "Saved successfully");
return(operationResponse);
}
catch (Exception e)
{
Log.Error(e.Message + " " + e.StackTrace);
operationResponse.OnException(e.Message);
return(operationResponse);
}
}
private void btnSubmit_Click(object sender, EventArgs e)
{
if (cboxUserType.SelectedItem.ToString().Equals("Employee User"))
{
_user = new Employee();
_user.User_Type = 2;
_user.First_Name = txtFName.Text;
_user.Last_Name = txtLName.Text;
_user.Address = txtAddress.Text;
_user.Birthday = dpBirthday.Value.Date;
_user.NIC = txtNIC.Text;
_user.Gender = rbtnMale.Checked ? rbtnMale.Text : _user.Gender;
_user.Gender = rbtnFemale.Checked ? rbtnFemale.Text : _user.Gender;
errorFName.Clear();
ValidationResult validationResult = _employeeValidator.Validate((Employee)_user);
if (!validationResult.IsValid)
{
foreach (ValidationFailure validationResultError in validationResult.Errors)
{
if (validationResultError.PropertyName.Equals(nameof(_user.First_Name)))
{
errorFName.SetError(txtFName, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Last_Name)))
{
errorFName.SetError(txtLName, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Address)))
{
errorFName.SetError(txtAddress, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.NIC)))
{
errorFName.SetError(txtNIC, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Birthday)))
{
errorFName.SetError(dpBirthday, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.User_Type)))
{
errorFName.SetError(cboxUserType, validationResultError.ErrorMessage);
}
}
}
else
{
if (_employeeService.AddNewEmployee(_user, StaticResource.UseType.EMPLOYEE_USER) > 0)
{
DialogResult dialogResult = MessageBox.Show("Successfully Added!\nDo you want to add more..?",
"Result",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (dialogResult == DialogResult.Yes)
{
clearForm();
}
else
{
Close();
}
}
else
{
DialogResult dialogResult = MessageBox.Show("Added Failed!", "Result",
MessageBoxButtons.RetryCancel, MessageBoxIcon.Error);
if (dialogResult == DialogResult.Cancel)
{
Close();
}
}
}
}
else if (cboxUserType.SelectedItem.ToString().Equals("Admin User"))
{
_user = new AdminUser();
_user.User_Type = 1;
_user.First_Name = txtFName.Text;
_user.Last_Name = txtLName.Text;
_user.Address = txtAddress.Text;
_user.Birthday = dpBirthday.Value.Date;
_user.NIC = txtNIC.Text;
_user.Gender = rbtnMale.Checked ? rbtnMale.Text : _user.Gender;
_user.Gender = rbtnFemale.Checked ? rbtnFemale.Text : _user.Gender;
errorFName.Clear();
ValidationResult validationResult = _adminValidator.Validate((AdminUser)_user);
if (!validationResult.IsValid)
{
foreach (ValidationFailure validationResultError in validationResult.Errors)
{
if (validationResultError.PropertyName.Equals(nameof(_user.First_Name)))
{
errorFName.SetError(txtFName, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Last_Name)))
{
errorFName.SetError(txtLName, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Address)))
{
errorFName.SetError(txtAddress, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.NIC)))
{
errorFName.SetError(txtNIC, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Birthday)))
{
errorFName.SetError(dpBirthday, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.User_Type)))
{
errorFName.SetError(cboxUserType, validationResultError.ErrorMessage);
}
}
}
else
{
if (_employeeService.AddNewEmployee(_user, StaticResource.UseType.ADMIN_USER) > 0)
{
DialogResult dialogResult = MessageBox.Show("Successfully Added!\nDo you want to add more..?",
"Result",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (dialogResult == DialogResult.Yes)
{
clearForm();
}
else
{
Close();
}
}
else
{
DialogResult dialogResult = MessageBox.Show("Added Failed!", "Result",
MessageBoxButtons.RetryCancel, MessageBoxIcon.Error);
if (dialogResult == DialogResult.Cancel)
{
Close();
}
}
}
}
else if (cboxUserType.SelectedItem.ToString().Equals("Client"))
{
_user = new Client();
_user.User_Type = 3;
_user.First_Name = txtFName.Text;
_user.Last_Name = txtLName.Text;
_user.Address = txtAddress.Text;
_user.Birthday = dpBirthday.Value.Date;
_user.NIC = txtNIC.Text;
_user.Gender = rbtnMale.Checked ? rbtnMale.Text : _user.Gender;
_user.Gender = rbtnFemale.Checked ? rbtnFemale.Text : _user.Gender;
errorFName.Clear();
ValidationResult validationResult = _clientValidator.Validate((Client)_user);
if (!validationResult.IsValid)
{
foreach (ValidationFailure validationResultError in validationResult.Errors)
{
if (validationResultError.PropertyName.Equals(nameof(_user.First_Name)))
{
errorFName.SetError(txtFName, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Last_Name)))
{
errorFName.SetError(txtLName, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Address)))
{
errorFName.SetError(txtAddress, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.NIC)))
{
errorFName.SetError(txtNIC, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.Birthday)))
{
errorFName.SetError(dpBirthday, validationResultError.ErrorMessage);
}
else if (validationResultError.PropertyName.Equals(nameof(_user.User_Type)))
{
errorFName.SetError(cboxUserType, validationResultError.ErrorMessage);
}
}
}
else
{
if (_employeeService.AddNewEmployee(_user, StaticResource.UseType.CLIENT_USER) > 0)
{
DialogResult dialogResult = MessageBox.Show("Successfully Added!\nDo you want to add more..?",
"Result",
MessageBoxButtons.YesNo, MessageBoxIcon.Information);
if (dialogResult == DialogResult.Yes)
{
clearForm();
}
else
{
Close();
}
}
else
{
DialogResult dialogResult = MessageBox.Show("Added Failed!", "Result",
MessageBoxButtons.RetryCancel, MessageBoxIcon.Error);
if (dialogResult == DialogResult.Cancel)
{
Close();
}
}
}
}
}
