paginator-utils 0.2.2

Shared pagination response structures
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

use serde::{Deserialize, Serialize};

#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
pub struct SearchParams {
    pub query: String,
    pub fields: Vec<String>,
    #[serde(default)]
    pub case_sensitive: bool,
    #[serde(default)]
    pub exact_match: bool,
}

impl SearchParams {
    pub fn new(query: impl Into<String>, fields: Vec<String>) -> Self {
        Self {
            query: query.into(),
            fields,
            case_sensitive: false,
            exact_match: false,
        }
    }

    pub fn with_case_sensitive(mut self, sensitive: bool) -> Self {
        self.case_sensitive = sensitive;
        self
    }

    pub fn with_exact_match(mut self, exact: bool) -> Self {
        self.exact_match = exact;
        self
    }

    pub fn to_sql_where(&self) -> String {
        let pattern = if self.exact_match {
            format!("'{}'", self.query.replace('\'', "''"))
        } else {
            format!("'%{}%'", self.query.replace('\'', "''"))
        };

        let operator = if self.case_sensitive { "LIKE" } else { "ILIKE" };

        let conditions: Vec<String> = self
            .fields
            .iter()
            .map(|field| {
                if self.case_sensitive || operator == "ILIKE" {
                    format!("{} {} {}", field, operator, pattern)
                } else {
                    format!("LOWER({}) LIKE LOWER({})", field, pattern)
                }
            })
            .collect();

        format!("({})", conditions.join(" OR "))
    }
}