ostring_sqlx 2.0.3

A basic configuration persistence wrapper
Documentation 
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
88
89
90
91
92
93
94
95
96
97

pub mod tab_auth;
pub mod tab_conf;
pub mod tab_user;
pub mod tab_userconf;

use anyhow::Result;
use sqlx::sqlite::{Sqlite, SqlitePoolOptions};
use sqlx::Pool;
use tab_auth::{AuthOption, AuthQB};
use tab_conf::{ConfOption, ConfQB};
use tab_user::{UserOption, UserQB, Verify};
use tab_userconf::{UconfOption, UconfQB};

#[derive(Debug, Clone)]
pub struct OSqliteMan {
    pool: Pool<Sqlite>,
}

impl ConfOption {}

impl OSqliteMan {
    pub async fn init(sql_url: String) -> Result<Self> {
        let pool = SqlitePoolOptions::new().connect(&sql_url).await?;
        Self::init_table(pool.clone()).await?;

        Ok(OSqliteMan { pool })
    }
    pub async fn init_table(pool: Pool<Sqlite>) -> Result<()> {
        AuthQB::new(pool.clone()).init_table().await?;
        UserQB::new(pool.clone()).init_table().await?;
        ConfQB::new(pool.clone()).init_table().await?;
        UconfQB::new(pool.clone()).init_table().await?;
        Ok(())
    }

    pub async fn add_user(&self, user: UserOption) -> Result<()> {
        let query_build = UserQB::new(self.pool.clone());
        let query_build = query_build.set_parm(user);
        match query_build.clone().confirm().await? {
            Verify::Success => println!("the user confirm pass"),
            Verify::PwdError => println!("PwdError"),
            Verify::NotFond => {
                query_build.clone().regist().await?;
            }
        }
        Ok(())
    }

    pub async fn init_conf(&self, conf: ConfOption) -> Result<()> {
        let query_build = ConfQB::new(self.pool.clone());
        query_build.set_parm(conf).init_conf().await?;
        Ok(())
    }

    pub async fn get_user_id(self, _user: UserOption) -> Result<Option<i32>> {
        Ok(Some(1))
    }

    pub async fn get_conf_id(self, conf_name: String) -> Result<Option<i32>> {
        let query_build = ConfQB::new(self.pool.clone());
        let conf_id = query_build.get_conf_id(conf_name).await?;
        Ok(conf_id)
    }

    pub async fn read_auth(self, auth: AuthOption) -> Result<Option<String>> {
        let query_build = AuthQB::new(self.pool.clone());
        query_build.set_parm(auth).read().await
    }

    pub async fn save_auth(self, auth: AuthOption) -> Result<()> {
        let query_build = AuthQB::new(self.pool.clone());
        query_build.set_parm(auth).save().await?;
        Ok(())
    }

    pub async fn get_all_user_conf(self, uconf: UconfOption) -> Result<Vec<UconfOption>> {
        let query_build = UconfQB::new(self.pool.clone());
        query_build.set_parm(uconf).get_all().await
    }

    pub async fn read_user_conf(self, uconf: UconfOption) -> Result<Option<String>> {
        let query_build = UconfQB::new(self.pool.clone());
        query_build.set_parm(uconf).read().await
    }

    pub async fn save_user_conf(self, uconf: UconfOption) -> Result<()> {
        let uconf_query_build = UconfQB::new(self.pool.clone());
        uconf_query_build.set_parm(uconf).save().await?;
        Ok(())
    }

    pub async fn remove_user_conf(self, uconf: UconfOption) -> Result<()> {
        let uconf_query_build = UconfQB::new(self.pool.clone());
        uconf_query_build.set_parm(uconf).remove().await?;
        Ok(())
    }
}