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

use crate::db::schema::voteplans;
use diesel::{ExpressionMethods, Insertable, Queryable};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq, Queryable)]
pub struct Voteplan {
    pub id: i32,
    #[serde(alias = "chainVoteplanId")]
    pub chain_voteplan_id: String,
    #[serde(alias = "chainVoteStartTime")]
    #[serde(serialize_with = "crate::utils::serde::serialize_unix_timestamp_as_rfc3339")]
    #[serde(deserialize_with = "crate::utils::serde::deserialize_unix_timestamp_from_rfc3339")]
    pub chain_vote_start_time: i64,
    #[serde(alias = "chainVoteEndTime")]
    #[serde(serialize_with = "crate::utils::serde::serialize_unix_timestamp_as_rfc3339")]
    #[serde(deserialize_with = "crate::utils::serde::deserialize_unix_timestamp_from_rfc3339")]
    pub chain_vote_end_time: i64,
    #[serde(alias = "chainCommitteeEndTime")]
    #[serde(serialize_with = "crate::utils::serde::serialize_unix_timestamp_as_rfc3339")]
    #[serde(deserialize_with = "crate::utils::serde::deserialize_unix_timestamp_from_rfc3339")]
    pub chain_committee_end_time: i64,
    #[serde(alias = "chainVoteplanPayload")]
    pub chain_voteplan_payload: String,
    #[serde(alias = "chainVoteEncryptionKey")]
    pub chain_vote_encryption_key: String,
    #[serde(alias = "fundId")]
    pub fund_id: i32,
    #[serde(alias = "tokenId")]
    pub token_identifier: String,
}

// This warning is disabled here. Values is only referenced as a type here. It should be ok not to
// split the types definitions.
#[allow(clippy::type_complexity)]
impl Insertable<voteplans::table> for Voteplan {
    type Values = (
        diesel::dsl::Eq<voteplans::chain_voteplan_id, String>,
        diesel::dsl::Eq<voteplans::chain_vote_start_time, i64>,
        diesel::dsl::Eq<voteplans::chain_vote_end_time, i64>,
        diesel::dsl::Eq<voteplans::chain_committee_end_time, i64>,
        diesel::dsl::Eq<voteplans::chain_voteplan_payload, String>,
        diesel::dsl::Eq<voteplans::chain_vote_encryption_key, String>,
        diesel::dsl::Eq<voteplans::fund_id, i32>,
        diesel::dsl::Eq<voteplans::token_identifier, String>,
    );

    fn values(self) -> Self::Values {
        (
            voteplans::chain_voteplan_id.eq(self.chain_voteplan_id),
            voteplans::chain_vote_start_time.eq(self.chain_vote_start_time),
            voteplans::chain_vote_end_time.eq(self.chain_vote_end_time),
            voteplans::chain_committee_end_time.eq(self.chain_committee_end_time),
            voteplans::chain_voteplan_payload.eq(self.chain_voteplan_payload),
            voteplans::chain_vote_encryption_key.eq(self.chain_vote_encryption_key),
            voteplans::fund_id.eq(self.fund_id),
            voteplans::token_identifier.eq(self.token_identifier),
        )
    }
}

#[cfg(test)]
pub mod test {
    use crate::db::{models::voteplans::Voteplan, schema::voteplans, DbConnectionPool};
    use diesel::{ExpressionMethods, RunQueryDsl};
    use time::OffsetDateTime;

    pub fn get_test_voteplan_with_fund_id(fund_id: i32) -> Voteplan {
        Voteplan {
            id: 1,
            chain_voteplan_id: format!("test_vote_plan{fund_id}"),
            chain_vote_start_time: OffsetDateTime::now_utc().unix_timestamp(),
            chain_vote_end_time: OffsetDateTime::now_utc().unix_timestamp(),
            chain_committee_end_time: OffsetDateTime::now_utc().unix_timestamp(),
            chain_voteplan_payload: "foopayload".to_string(),
            chain_vote_encryption_key: "enckey".to_string(),
            fund_id,
            token_identifier: "token_id".to_string(),
        }
    }

    pub fn populate_db_with_voteplan(voteplan: &Voteplan, pool: &DbConnectionPool) {
        let connection = pool.get().unwrap();
        let values = (
            voteplans::chain_voteplan_id.eq(voteplan.chain_voteplan_id.clone()),
            voteplans::chain_vote_start_time.eq(voteplan.chain_vote_start_time),
            voteplans::chain_vote_end_time.eq(voteplan.chain_vote_end_time),
            voteplans::chain_committee_end_time.eq(voteplan.chain_committee_end_time),
            voteplans::chain_voteplan_payload.eq(voteplan.chain_voteplan_payload.clone()),
            voteplans::chain_vote_encryption_key.eq(voteplan.chain_vote_encryption_key.clone()),
            voteplans::fund_id.eq(voteplan.fund_id),
            voteplans::token_identifier.eq(voteplan.token_identifier.clone()),
        );

        diesel::insert_into(voteplans::table)
            .values(values)
            .execute(&connection)
            .unwrap();
    }
}