public void Add(Contact cont)
{
try
{
ValidationResult results = validator.Validate(cont);
if (results.IsValid)
{
_dalContact.Add(cont);
}
else
{
//!results.IsValid
if (results.Errors != null && results.Errors.Count > 0)
{
foreach (var failure in results.Errors)
{
throw new Exception($"Property {failure.PropertyName} failed validation. Error was: {failure.ErrorMessage}");
}
}
}
}
catch (ValidationException e)
{
throw new Exception($"validation error: {e.ToString()}");
}
catch (Exception ex)
{
throw new Exception(ex.Message);
}
}
public async Task <Contact> Update(ContactDTO contact, CancellationToken cancellationToken)
{
ValidationResult result = _validator.Validate(contact);
if (!result.IsValid)
{
ValidationException exception = new ValidationException(nameof(contact));
foreach (ValidationFailure failure in result.Errors)
{
exception._errors.Add(failure.PropertyName, failure.ErrorMessage);
}
throw exception;
}
try
{
var contactEntity = _mapper.Map <Contact>(contact);
await _repository.Update(contactEntity, cancellationToken);
return(contactEntity);
}
catch (Exception e)
{
throw new UpdateException(contact.Id, e);
}
}
public bool Create(ContactCreateApiModel apiModel, int createdUser)
{
var validator = _contactValidator.Validate(apiModel);
if (validator.IsValid)
{
return(_contactRepository.Create(apiModel, createdUser));
}
return(false);
}
// PUT: api/ContactInformation
public IHttpActionResult Put(Contact contact)
{
var validator = new ContactValidator();
var apiResponse = new ApiResponse();
var results = validator.Validate(contact);
if (!results.IsValid)
{
apiResponse.Errors = new Errors(results.Errors);
return(Ok(apiResponse));
}
var isUpdated = ContactRepository.Update(contact);
if (!isUpdated)
{
apiResponse.Errors = new Errors {
new Error {
ResponseCode = ResponseCodes.ContactNotFound
}
};
}
return(Ok(apiResponse));
}
public void ValidContact_ReturnsSuccess()
{
var contact = ContactTestData.GetValidTestContact();
var result = validator.Validate(contact);
Assert.True(result.IsValid);
}
public ActionResult AddContact(Contact p)
{
ValidationResult results = contactValidator.Validate(p);
if (results.IsValid)
{
cm.ContactAdd(p);
return(RedirectToAction("Index"));
}
else
{
foreach (var item in results.Errors)
{
ModelState.AddModelError(item.PropertyName, item.ErrorMessage);
}
}
return(View());
}
public void Validate_NonAdmin_Update_Returns_Error(string role)
{
var ctx = Creator.GetContext(role: role);
_context.Setup(c => c.HttpContext).Returns(ctx);
var validator = new ContactValidator(_context.Object);
var valres = validator.Validate(new Contact(), ruleSet: nameof(IContactLogic.Update));
valres.Errors.Count().Should().Be(1);
}
public void Validate_Admin_Delete_Completes(string role)
{
var ctx = Creator.GetContext(role: role);
_context.Setup(c => c.HttpContext).Returns(ctx);
var validator = new ContactValidator(_context.Object);
var valres = validator.Validate(new Contact(), ruleSet: nameof(IContactLogic.Delete));
valres.Errors.Should().BeEmpty();
}
public void ValidationPhoneTest()
{
Contact contact = GetContactModel();
contact.Email = "12121121tt";
var validator = new ContactValidator();
var result = validator.Validate(contact);
Assert.Equals(result.Errors.First().ErrorCode.Equals(ResponseCodes.InvalidFirstName), true);
}
private void saveButton_Click(object sender, EventArgs e)
{
HttpResponseMessage response = new HttpResponseMessage();
ContactValidator validator = new ContactValidator();
Contact contact = new Contact {
FirstName = firstNameTextBox.Text, LastName = lastNameTextBox.Text, Email = emailTextBox.Text, Phone = phoneNoTextBox.Text.Trim(), IsActive = true
};
if (_contact == null)
{
if (validator.Validate(contact))
{
response = _client.PostAsJsonAsync("Contacts", contact).Result;
if (response.IsSuccessStatusCode)
{
Success();
}
else
{
Failure(response);
}
}
}
else
{
if (validator.Validate(contact))
{
string uri = "Contacts?id=" + _contact.Id.ToString();
contact.Id = _contact.Id;
response = _client.PutAsJsonAsync(uri, contact).Result;
if (response.IsSuccessStatusCode)
{
Success();
}
else
{
Failure(response);
}
}
}
}
public bool IsBroken()
{
var validator = new ContactValidator();
var result = validator.Validate(_contact);
if (!result.IsValid)
{
_message = string.Join(", ", result.Errors.Select(e => e.ErrorMessage));
return(true);
}
return(false);
}
public async Task <IActionResult> Create([FromBody] AddContactModel item)
{
var result = _contactValidator.Validate(item);
if (result.IsValid)
{
int itemId = await _contactService.CreateAsync(item);
return(CreatedAtAction(nameof(Get), new { id = itemId }, item));
}
else
{
return(BadRequest(result.Errors.Select(t => t.ErrorMessage)));
}
}
public ActionResult Edit(Contact cont)
{
ContactValidator validator = new ContactValidator();
ValidationResult result = validator.Validate(cont);
if (!result.IsValid)
{
foreach (ValidationFailure failer in result.Errors)
{
ModelState.AddModelError(failer.PropertyName, failer.ErrorMessage);
}
}
return(View(cont));
}
// POST: api/ContactInformation
public IHttpActionResult Post(Contact value)
{
var validator = new ContactValidator();
var apiResponse = new ApiResponse();
//validate the model
var results = validator.Validate(value);
if (!results.IsValid)
{
apiResponse.Errors = new Errors(results.Errors);
return(Ok(apiResponse));
}
apiResponse.Data = ContactRepository.Add(value);
return(Ok(apiResponse));
}
private void Validate(Contact contact)
{
ContactValidator validator = new ContactValidator();
var results = validator.Validate(contact);
if (results.IsValid == false)
{
foreach (ValidationFailure failure in results.Errors)
{
errors.Add(failure.ErrorMessage);
MessageBox.Show(failure.ErrorMessage);
}
}
else
{
Contacts.Add(contact);
SavedContacts.Add(contact);
}
}
public bool TryImportFrom(string filePath, out ContactList contactList)
{
contactList = new ContactList();
try
{
contactList = ImportFrom(filePath);
if (ContactValidator.Validate(contactList) || TryToNormalize(contactList))
{
return(true);
}
}
catch (Exception ex)
{
Console.WriteLine($"\n{ex.Message}");
}
return(false);
}
public async Task <Result> InsertContact(ScopeOptions scope, Contact contact)
{
var validator = new ContactValidator(_context, scope, true);
var result = validator.Validate(contact).GetResult();
if (!result.Success)
{
return(result);
}
var entity = MapModelToEntity(contact);
await _context.Contact.AddAsync(entity);
await _context.SaveChangesAsync();
contact.Id = entity.Id;
result.Tag = contact;
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_INSERT, "Contact", entity.Id, contact);
return(result);
}
public async Task <Result> UpdateContact(ScopeOptions scope, Contact contact)
{
var validator = new ContactValidator(_context, scope, false);
var result = validator.Validate(contact).GetResult();
if (!result.Success)
{
return(result);
}
var entity = await GetContactEntityQuery(scope).FirstOrDefaultAsync(b => b.Id == contact.Id);
if (entity == null)
{
return(new Result());
}
entity = MapModelToEntity(contact, entity);
await _context.SaveChangesAsync();
await _auditService.InsertAuditLog(scope, AuditLog.ACTION_UPDATE, "Contact", entity.Id, contact);
return(result);
}
static void Main()
{
List <Contact> contacts = new List <Contact>();
Contact contact = new Contact
{
Id = 1,
FirstName = "Valentino",
LastName = "Skobljanec",
Gender = "Male",
//BirthDay = new DateTime(1992,9,7),
BirthPlace = "Rijeka",
Comment = "first user!"
};
ContactValidator contactValidator = new ContactValidator();
ValidationResult results = contactValidator.Validate(contact);
ValidationResults(results);
Email mainEmail = new Email
{
Address = "*****@*****.**",
Type = "Home"
};
//EmailValidator emailValidator = new EmailValidator();
//results = emailValidator.Validate(mainEmail);
//ValidationResults(results);
contact.AddEmail(mainEmail);
Email schoolEmail = new Email
{
Address = "*****@*****.**",
Type = "School"
};
contact.AddEmail(schoolEmail);
contact.RemoveEmail(schoolEmail);
Address addreess = new Address
{
Street = "Ilica",
Number = 47,
City = "Zagreb",
Zip = 10000,
Country = "Croatia"
};
AddressValidator addressValidator = new AddressValidator();
results = addressValidator.Validate(addreess);
ValidationResults(results);
contact.AddAddress(addreess);
SocialAccount socialAccount = new SocialAccount
{
Id = "pytagora",
Network = "Github"
};
SocialAccountValidator socialAccountValidator = new SocialAccountValidator();
results = socialAccountValidator.Validate(socialAccount);
ValidationResults(results);
contact.AddSocialAccount(socialAccount);
PhoneNumber phoneNumber = new PhoneNumber
{
Number = "1313164",
Type = "Home"
};
PhoneNumberValidator phoneNumberValidator = new PhoneNumberValidator();
results = phoneNumberValidator.Validate(phoneNumber);
ValidationResults(results);
contact.AddPhoneNumber(phoneNumber);
var tmp = contact.GetEmails();
foreach (var item in tmp)
{
Console.WriteLine("{0} - {1}", item.Address, item.Type);
}
contacts.Add(contact);
Contact user = new Contact
{
FirstName = "Ivo",
LastName = "Ivic",
Gender = "Male",
};
contacts.Add(user);
JsonSerializer serializer = new JsonSerializer();
serializer.Converters.Add(new JavaScriptDateTimeConverter());
serializer.NullValueHandling = NullValueHandling.Ignore;
string jsonFile = @"..\\json.txt";
using (StreamWriter streamWriter = new StreamWriter(jsonFile))
using (JsonWriter jsonWriter = new JsonTextWriter(streamWriter))
{
//serializer.Serialize(jsonWriter, contacts);
var settings = new JsonSerializerSettings()
{
ContractResolver = new MyContractResolver()
};
var json = JsonConvert.SerializeObject(contacts, settings);
serializer.Serialize(jsonWriter, json);
}
/*using (StreamReader r = new StreamReader(jsonFile))
* {
* string json = r.ReadToEnd();
* List<Contact> writeContacts = JsonConvert.DeserializeObject<List<Contact>>(json);
* foreach (var item in writeContacts)
* {
* Console.WriteLine("{0} - {1} - {2}", item.FirstName, item.LastName, item.Gender);
* }
* }*/
Contact john = new Contact();
john.FirstName = "John";
john.LastName = "Doe";
john.BirthPlace = "Seattle";
/*using (var outputFile = File.Create("john.dat"))
* {
* john.WriteTo(outputFile);
* }*/
Console.WriteLine("\nProcess done. Press any key to exit.");
Console.ReadKey();
}
private void RemoveInvalidContacts(ContactList contactList)
{
contactList.Contacts.RemoveAll((contact) => (!ContactValidator.Validate(contact)));
}
