summaryrefslogtreecommitdiff
path: root/src/database/user.rs
blob: d3202cedcfe8b7aedb786367465166b90ce25c7a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
use crate::database::DatabaseWrapper;
use serde::{Deserialize, Serialize};
use sqlx::mysql::MySqlQueryResult;
use utoipa::ToSchema;

#[derive(Deserialize, Serialize)]
pub struct User {
    pub id: Option<i32>,
    pub name: Option<String>,
    password: Option<String>,
}

#[derive(Deserialize, Serialize, ToSchema)]
pub struct UserForm {
    #[schema(example = "username")]
    name: Option<String>,
    #[schema(example = "password")]
    password: Option<String>,
}

impl DatabaseWrapper {
    pub async fn register(&self, data: UserForm) -> Result<MySqlQueryResult, sqlx::Error> {
        if data.name.is_none() || data.password.is_none() {
            return Err(sqlx::Error::RowNotFound);
        }

        sqlx::query!(
            "INSERT INTO user (name, password)
            VALUE (?, PASSWORD(?))",
            data.name,
            data.password,
        )
        .execute(&self.db_pool)
        .await
    }

    pub async fn login(&self, data: UserForm) -> Result<Option<User>, sqlx::Error> {
        if data.name.is_none() || data.password.is_none() {
            return Err(sqlx::Error::RowNotFound);
        }

        sqlx::query_as!(
            User,
            "SELECT * FROM user
            WHERE ? = name
            AND password(?) = password
            ",
            data.name,
            data.password,
        )
        .fetch_optional(&self.db_pool)
        .await
    }

    pub async fn delete_user(&self, data: UserForm) -> Result<MySqlQueryResult, sqlx::Error> {
        if data.name.is_none() || data.password.is_none() {
            return Err(sqlx::Error::RowNotFound);
        }

        match sqlx::query_as!(
            User,
            "SELECT * FROM user
            WHERE name = ?
            AND password = password(?)
            ",
            data.name,
            data.password,
        )
        .fetch_one(&self.db_pool)
        .await
        {
            Ok(_) => (),
            Err(_) => return Err(sqlx::Error::RowNotFound),
        };

        sqlx::query!(
            "DELETE FROM user
            WHERE name = ?
            AND password = password(?)
            ",
            data.name,
            data.password,
        )
        .execute(&self.db_pool)
        .await
    }
}