pub use common::*;

use sqlx::{query, query_as};

use sqlx::query_as;

    pub async fn find(db: &State<Database>, id: i32) -> Result<Self, sqlx::Error> {
        query_as!(User, "SELECT * FROM users WHERE id = $1", id)
            .fetch_one(&**db)
            .await
    }
    pub async fn create(&self, db: &State<Database>) -> Result<i32, sqlx::Error> {
        let result = query!(
            "INSERT INTO users (name, email, password) VALUES ($1, $2, crypt($3, gen_salt('bf'))) RETURNING id",
            &self.name,
            &self.email.to_lowercase(),
            &self.password

    pub async fn create(
        db: &State<Database>,
        name: String,
        password: String,
        email: String,
    ) -> Result<Self, sqlx::Error> {
        let result = query_as!( User,
            "INSERT INTO users (name, email, password) VALUES ($1, $2, crypt($3, gen_salt('bf'))) RETURNING *",
            &name,
            &email.to_lowercase(),
            &password

        // TODO when I figure out Rust, update self with this id
        Ok(result.id)

        Ok(result)
    }
    pub async fn find(db: &State<Database>, id: i32) -> Result<Self, sqlx::Error> {
        query_as!(User, "SELECT * FROM users WHERE id = $1", id)
            .fetch_one(&**db)
            .await

    // TODO When the form parsing fails, the users gets no feedback
    let mut new_user = User {
        id: -1,
        name: user.user_name.clone(),
        email: user.email.clone(),
        password: user.password.clone(),
    };
    match new_user.create(db).await {
        Ok(id) => {
            new_user.id = id;

    match User::create(
        db,
        user.user_name.clone(),
        user.password.clone(),
        user.email.clone(),
    )
    .await
    {
        Ok(new_user) => {

rand = "0.8.4"

 "rand 0.8.4",