tetratto-core 18.0.1

The core behind Tetratto
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

use oiseau::cache::Cache;
use crate::model::communities::Poll;
use crate::model::moderation::AuditLogEntry;
use crate::model::{Error, Result, auth::User, permissions::FinePermission};
use crate::{auto_method, DataManager};

use oiseau::PostgresRow;

use oiseau::{execute, get, query_rows, params};

impl DataManager {
    /// Get a [`Poll`] from an SQL row.
    pub(crate) fn get_poll_from_row(x: &PostgresRow) -> Poll {
        Poll {
            id: get!(x->0(i64)) as usize,
            owner: get!(x->1(i64)) as usize,
            created: get!(x->2(i64)) as usize,
            expires: get!(x->3(i32)) as usize,
            option_a: get!(x->4(String)),
            option_b: get!(x->5(String)),
            option_c: get!(x->6(String)),
            option_d: get!(x->7(String)),
            votes_a: get!(x->8(i32)) as usize,
            votes_b: get!(x->9(i32)) as usize,
            votes_c: get!(x->10(i32)) as usize,
            votes_d: get!(x->11(i32)) as usize,
        }
    }

    auto_method!(get_poll_by_id()@get_poll_from_row -> "SELECT * FROM polls WHERE id = $1" --name="poll" --returns=Poll --cache-key-tmpl="atto.poll:{}");

    /// Get all polls by their owner.
    ///
    /// # Arguments
    /// * `owner` - the ID of the owner of the polls
    pub async fn get_polls_by_owner_all(&self, owner: usize) -> Result<Vec<Poll>> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_rows!(
            &conn,
            "SELECT * FROM polls WHERE owner = $1 ORDER BY created DESC",
            &[&(owner as i64)],
            |x| { Self::get_poll_from_row(x) }
        );

        if res.is_err() {
            return Err(Error::GeneralNotFound("poll".to_string()));
        }

        Ok(res.unwrap())
    }

    /// Create a new poll in the database.
    ///
    /// # Arguments
    /// * `data` - a mock [`Poll`] object to insert
    pub async fn create_poll(&self, data: Poll) -> Result<usize> {
        // check values
        if data.option_a.len() < 2 {
            return Err(Error::DataTooShort("option A".to_string()));
        } else if data.option_a.len() > 128 {
            return Err(Error::DataTooLong("option A".to_string()));
        }

        if data.option_b.len() < 2 {
            return Err(Error::DataTooShort("option B".to_string()));
        } else if data.option_b.len() > 128 {
            return Err(Error::DataTooLong("option B".to_string()));
        }

        if data.option_c.len() > 128 {
            return Err(Error::DataTooLong("option C".to_string()));
        }

        if data.option_d.len() > 128 {
            return Err(Error::DataTooLong("option D".to_string()));
        }

        // ...
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = execute!(
            &conn,
            "INSERT INTO polls VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)",
            params![
                &(data.id as i64),
                &(data.owner as i64),
                &(data.created as i64),
                &(data.expires as i32),
                &data.option_a,
                &data.option_b,
                &data.option_c,
                &data.option_d,
                &(data.votes_a as i32),
                &(data.votes_b as i32),
                &(data.votes_c as i32),
                &(data.votes_d as i32),
            ]
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        Ok(data.id)
    }

    pub async fn delete_poll(&self, id: usize, user: &User) -> Result<()> {
        let y = self.get_poll_by_id(id).await?;

        if user.id != y.owner {
            if !user.permissions.check(FinePermission::MANAGE_POSTS) {
                return Err(Error::NotAllowed);
            } else {
                self.create_audit_log_entry(AuditLogEntry::new(
                    user.id,
                    format!("invoked `delete_poll` with x value `{id}`"),
                ))
                .await?
            }
        }
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = execute!(&conn, "DELETE FROM polls WHERE id = $1", &[&(id as i64)]);

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        self.0.1.remove(format!("atto.poll:{}", id)).await;

        // remove votes
        let res = execute!(
            &conn,
            "DELETE FROM pollvotes WHERE poll_id = $1",
            &[&(id as i64)]
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        // ...
        Ok(())
    }

    pub async fn cache_clear_poll(&self, poll: &Poll) {
        self.0.1.remove(format!("atto.poll:{}", poll.id)).await;
    }

    auto_method!(incr_votes_a_count()@get_poll_by_id -> "UPDATE polls SET votes_a = votes_a + 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --incr);
    auto_method!(decr_votes_a_count()@get_poll_by_id -> "UPDATE polls SET votes_a = votes_a - 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --decr=votes_a);

    auto_method!(incr_votes_b_count()@get_poll_by_id -> "UPDATE polls SET votes_b = votes_b + 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --incr);
    auto_method!(decr_votes_b_count()@get_poll_by_id -> "UPDATE polls SET votes_b = votes_b - 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --decr=votes_b);

    auto_method!(incr_votes_c_count()@get_poll_by_id -> "UPDATE polls SET votes_c = votes_d + 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --incr);
    auto_method!(decr_votes_c_count()@get_poll_by_id -> "UPDATE polls SET votes_c = votes_d - 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --decr=votes_c);

    auto_method!(incr_votes_d_count()@get_poll_by_id -> "UPDATE polls SET votes_d = votes_d + 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --incr);
    auto_method!(decr_votes_d_count()@get_poll_by_id -> "UPDATE polls SET votes_d = votes_d - 1 WHERE id = $1" --cache-key-tmpl=cache_clear_poll --decr=votes_d);
}