betting 0.3.1

A crate to manage twitch-style bets (aka 'Parimutuel betting')
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

use rusqlite::Connection;
use crate::{BetError, Outcome, BetInfo};

pub(crate) trait BetConnection {
    fn outcomes_of_bet(&self, bet: u64) -> Result<Vec<u64>, BetError>;

    fn outcome_status(
        &self, bet: u64, outcome: u64,
    ) -> Result<Outcome, BetError>;

    fn outcomes_statuses(
        &self, bet: u64
    ) -> Result<Vec<Outcome>, BetError>;

    fn assert_bet_not_deleted(&self, bet: u64) -> Result<(), BetError>;

    fn bet_info(&self, bet: u64) -> Result<BetInfo, BetError>;

    fn balance(&self, server: u64, user: u64) -> Result<u64, BetError>;
}

impl BetConnection for Connection {
    fn outcomes_of_bet(&self, bet: u64) -> Result<Vec<u64>, BetError> {
        Ok(self.prepare(
                "SELECT number 
                FROM Outcome
                WHERE bet = ?1",
            )
            .unwrap()
            .query_map([bet], |row| row.get::<usize, u64>(0))?
            .collect::<Result<Vec<_>, _>>()?)
    }

    fn outcome_status(
        &self, bet: u64, outcome: u64,
    ) -> Result<Outcome, BetError> {
        let desc = self.prepare(
            "SELECT desc
            FROM Outcome
            WHERE bet = ?1 AND number = ?2",
            )
            .unwrap()
            .query_row([bet, outcome], |row| row.get::<usize, String>(0))?;
        let mut stmt = self
            .prepare(
                "SELECT user, amount
                FROM Wager
                WHERE bet = ?1 AND outcome = ?2",
            )
            .unwrap();
        let mut rows = stmt.query([bet, outcome])?;
        let mut wagers = Vec::new();
        while let Some(row) = rows.next()? {
            wagers.push((row.get::<usize, u64>(0)?, row.get::<usize, u64>(1)?));
        }
        Ok(Outcome {
            desc: desc,
            wagers: wagers,
        })
    }

    fn outcomes_statuses(
        &self, bet: u64
    ) -> Result<Vec<Outcome>, BetError> {
        let outcomes = self.outcomes_of_bet(bet)?;
        outcomes
            .into_iter()
            .map(|opt| self.outcome_status(bet, opt))
            .collect::<Result<Vec<_>, _>>()
    }

    fn assert_bet_not_deleted(&self, bet: u64) -> Result<(), BetError> {
        if self.prepare(
            "SELECT * 
            FROM ToDelete
            WHERE bet = ?1
            ",
        )
        .unwrap()
        .exists([bet])?
        {
            Err(BetError::NotFound)
        } else {
            Ok(())
        }
    }

    fn bet_info(&self, bet: u64) -> Result<BetInfo, BetError> {
        let (desc, server, author, is_open) = self.prepare(
            "SELECT desc, server, author, is_open 
            FROM Bet
            WHERE uuid = ?1
            ",
        )
        .unwrap()
        .query_row(
            [bet], 
            |row| 
            Ok((
                row.get::<usize, String>(0)?,
                row.get::<usize, u64>(1)?, 
                row.get::<usize, u64>(2)?, 
                row.get::<usize, u32>(3)? != 0
            ))

        )?;
        Ok(BetInfo { desc, server, author, is_open })
    }

    fn balance(&self, server: u64, user: u64) -> Result<u64, BetError> {
        Ok(self.prepare(
                "SELECT balance 
                    FROM Account
                    WHERE server = ?1 AND user = ?2",
            )
            .unwrap()
            .query_row([server, user], |row| row.get::<usize, u64>(0))?)
    }
}