rnacos 0.8.3

Nacos server re-implemented in Rust.
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
98
99
100
101
102
103
104
105
106
107
108

use crate::common::sqlx_utils::MySqlExecutor;
use rsql_builder::B;
use serde::{Deserialize, Serialize};
use sqlx::Row;

#[derive(Debug, Default, Serialize, Deserialize, sqlx::FromRow)]
pub struct ConfigInfoDO {
    pub id: Option<i64>,
    pub data_id: Option<String>,
    pub group_id: Option<String>,
    pub content: Option<String>,
    pub md5: Option<String>,
    pub gmt_modified_timestamp: Option<i64>,
    pub src_user: Option<String>,
    pub src_ip: Option<String>,
    pub app_name: Option<String>,
    pub tenant_id: Option<String>,
    pub c_desc: Option<String>,
    pub c_use: Option<String>,
    pub effect: Option<String>,
    pub r#type: Option<String>,
    pub c_schema: Option<String>,
    pub encrypted_data_key: Option<String>,
}

#[derive(Debug, Default)]
pub struct ConfigInfoParam {
    pub id: Option<i64>,
    pub limit: Option<i64>,
    pub offset: Option<i64>,
}
pub struct ConfigInfoSql {}

impl ConfigInfoSql {
    fn conditions(&self, param: &ConfigInfoParam) -> B<'_> {
        let mut whr = B::new_where();
        if let Some(id) = &param.id {
            whr.eq("id", id);
        }
        whr
    }

    pub fn query_prepare(&self, param: &ConfigInfoParam) -> (String, Vec<serde_json::Value>) {
        B::prepare(
            B::new_sql("select id, data_id, group_id, content, md5, UNIX_TIMESTAMP(gmt_modified) \
            as gmt_modified_timestamp, src_user, src_ip, app_name, tenant_id, c_desc, c_use, effect, \
            type, c_schema, encrypted_data_key from config_info")
                .push_build(&mut self.conditions(param))
                .push_fn(||{
                    let mut b= B::new();
                    if let Some(limit) = &param.limit{
                        b.limit(limit);
                    }
                    if let Some(offset ) = &param.offset{
                        b.offset(offset);
                    }
                    b
                })
        )
    }

    pub fn query_count_prepare(&self, param: &ConfigInfoParam) -> (String, Vec<serde_json::Value>) {
        B::prepare(
            B::new_sql("select count(1) from config_info").push_build(&mut self.conditions(param)),
        )
    }
}

pub struct ConfigInfoDao<'a> {
    executor: MySqlExecutor<'a>,
    inner: ConfigInfoSql,
}

impl<'a> ConfigInfoDao<'a> {
    pub fn new(executor: MySqlExecutor<'a>) -> Self {
        Self {
            executor,
            inner: ConfigInfoSql {},
        }
    }

    pub async fn fetch(
        &mut self,
        sql: &str,
        args: &[serde_json::Value],
    ) -> anyhow::Result<Vec<ConfigInfoDO>> {
        self.executor.fetch(sql, args).await
    }

    pub async fn fetch_count(
        &mut self,
        sql: &str,
        args: &[serde_json::Value],
    ) -> anyhow::Result<i64> {
        let v = self.executor.fetch_row(sql, args).await?;
        v.try_get(0).map_err(anyhow::Error::msg)
    }

    pub async fn query(&mut self, param: &ConfigInfoParam) -> anyhow::Result<Vec<ConfigInfoDO>> {
        let (sql, args) = self.inner.query_prepare(param);
        self.fetch(&sql, &args).await
    }

    pub async fn query_count(&mut self, param: &ConfigInfoParam) -> anyhow::Result<i64> {
        let (sql, args) = self.inner.query_count_prepare(param);
        self.fetch_count(&sql, &args).await
    }
}