## error types
### Instructions
For this exercise, you will have to implement an **error type** for a form validator. This must validate the password and the first name.
The first name must not be empty and the password must have **at least 8 characters** , and a combination of **alphabetic** , **numeric** and **none-alphanumeric** (`< `, `&` , `/` ...).
Examples:
- `"asDd123=%"` : **good** .
- `"asgfD"` : **error** as it only contains alphabetic characters.
- `"asdsdf2"` : **error** as it is missing none-alphanumeric characters.
- `"sad\_#$"` : **error** as it is missing numeric characters.
Create a structure named `Form` that will have the following fields:
- `first_name` : `String`
- `last_name` : `String`
- `birth` : `NaiveDate` that will convert a string `"2015-09-05"` to a date of that format.
- `birth_location` : `String`
- `password` : `String`
You must implement the **associated functions** `new` and
`validate` that will validate the form.
For the error type you must create a `struct` named `FormError` . It must have the fields:
- `form_values` : this will be a tuple of strings representing the invalid input. For example: `("password", "asdaSD\_")` or `("first_name", "someone")`
- `date` : that will have the date that the error occurred in the format `"2020-12-14 09:33:41"`
- `err` : the error description:
- `"No user name"`
- `"At least 8 characters"`
- `"Combination of different ASCII character types (numbers, letters and none alphanumeric characters)"`
### Dependencies
chrono = "0.4"
### Expected Function
```rust
pub use chrono::{Utc, NaiveDate};
// this will be the structure that wil handle the errors
#[derive(Debug, Eq, PartialEq)]
pub struct FormError {
// expected public fields
}
impl FormError {
pub fn new(field_name: String, field_value: String, err: String) -> FormError {}
}
#[derive(Debug, Eq, PartialEq)]
pub struct Form {
// expected public fields
}
impl Form {
pub fn new(
first_name: String,
last_name: String,
birth: NaiveDate,
birth_location: String,
password: String,
) -> Form {}
pub fn validate(& self) -> Result< Vec < & str > , FormError> {}
}
```
### Usage
Here is a program to test your function:
```rust
use error_types::*;
fn main() {
let mut form_output = Form::new(
String::from("Lee"),
String::from("Silva"),
create_date("2015-09-05"),
String::from("Africa"),
String::from("qwqwsa1dty_"),
);
println!("{:?}", form_output);
println!("{:?}", form_output.validate().unwrap());
form_output.first_name = String::from("");
println!("{:?}", form_output.validate().unwrap_err());
form_output.first_name = String::from("as");
form_output.password = String::from("dty_1");
println!("{:?}", form_output.validate().unwrap_err());
form_output.password = String::from("asdasASd(_");
println!("{:?}", form_output.validate().unwrap_err());
form_output.password = String::from("asdasASd123SA");
println!("{:?}", form_output.validate().unwrap_err());
}
```
And its output:
```console
$ cargo run
Form { first_name: "Lee", last_name: "Silva", birth: 2015-09-05, birth_location: "Africa", password: "qwqwsa1dty_" }
["Valid first name", "Valid password"]
FormError { form_values: ("first_name", ""), date: "2022-10-17 12:09:25", err: "No user name" }
FormError { form_values: ("password", "dty_1"), date: "2022-10-17 12:09:25", err: "At least 8 characters" }
FormError { form_values: ("password", "asdasASd(_"), date: "2022-10-17 12:09:25", err: "Combination of different ASCII character types (numbers, letters and none alphanumeric characters)" }
FormError { form_values: ("password", "asdasASd123SA"), date: "2022-10-17 12:09:25", err: "Combination of different ASCII character types (numbers, letters and none alphanumeric characters)" }
$
```
### Notions
- [Error types ](https://doc.rust-lang.org/rust-by-example/error/multiple_error_types/define_error_type.html )
- [Struct NaiveDate ](https://docs.rs/chrono/0.4.19/chrono/naive/struct.NaiveDate.html )