oca_rs/repositories/
capture_base_cache_repo.rs

1use oca_bundle_semantics::state::oca::capture_base::CaptureBase;
2
3use crate::facade::Connection;
4
5#[derive(Debug)]
6pub struct CaptureBaseCacheRecord {
7    pub said: String,
8    pub capture_base: String,
9}
10
11impl CaptureBaseCacheRecord {
12    pub fn new(capture_base: &CaptureBase) -> Self {
13        Self {
14            said: capture_base.said.clone().unwrap().to_string(),
15            capture_base: serde_json::to_string(capture_base).unwrap(),
16        }
17    }
18}
19
20#[derive(Debug)]
21pub struct AllCaptureBaseRecord {
22    pub cache_record: Option<CaptureBaseCacheRecord>,
23    pub total: usize,
24}
25
26pub struct CaptureBaseCacheRepo {
27    connection: Connection,
28}
29
30impl CaptureBaseCacheRepo {
31    pub fn new(connection: Connection) -> Self {
32        let create_table_query = r#"
33        CREATE TABLE IF NOT EXISTS capture_base_cache(
34            said TEXT PRIMARY KEY,
35            capture_base TEXT
36        )"#;
37        let _ = connection.execute(create_table_query, ());
38
39        Self { connection }
40    }
41
42    pub fn insert(&self, model: CaptureBaseCacheRecord) {
43        let query = r#"
44        INSERT INTO capture_base_cache(said, capture_base)
45            VALUES (?1, ?2)"#;
46        let _ = self
47            .connection
48            .execute(query, [&model.said, &model.capture_base]);
49    }
50
51    pub fn fetch_all(&self, limit: usize, page: usize) -> Vec<AllCaptureBaseRecord> {
52        let offset = (page - 1) * limit;
53        let mut results = vec![];
54        let query = "
55        SELECT results.*, count.total
56        FROM
57        (
58            SELECT COUNT(*) OVER() AS total
59            FROM capture_base_cache
60        ) AS count
61        LEFT JOIN
62        (
63            SELECT *
64            FROM capture_base_cache
65            LIMIT ?1 OFFSET ?2
66        ) AS results
67        ON true
68        GROUP BY said";
69
70        let connection = self.connection.connection.lock().unwrap();
71        let mut statement = connection.prepare(query).unwrap();
72
73        let models = statement
74            .query_map([limit, offset], |row| {
75                let cache_record =
76                    row.get::<_, Option<String>>(0)
77                        .unwrap()
78                        .map(|said| CaptureBaseCacheRecord {
79                            said,
80                            capture_base: row.get(1).unwrap(),
81                        });
82                Ok(AllCaptureBaseRecord {
83                    cache_record,
84                    total: row.get(2).unwrap(),
85                })
86            })
87            .unwrap();
88        models.for_each(|model| results.push(model.unwrap()));
89        results
90    }
91}