nullnet-libdatastore 0.5.1

Nullnet datastore driver
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

use crate::datastore::{AdvanceFilter, EntityFieldFrom, EntityFieldTo, FieldRelation, Join};

#[derive(Debug, Default)]
pub struct JoinBuilder {
    r#type: String,
    to_entity: String,
    to_field: String,
    to_alias: String,
    to_limit: i32,
    to_order_by: String,
    to_filters: Vec<AdvanceFilter>,
    from_entity: String,
    from_field: String,
}

impl JoinBuilder {
    pub fn new() -> Self {
        Self::default()
    }

    pub fn r#type(mut self, value: impl Into<String>) -> Self {
        self.r#type = value.into();
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_entity(mut self, value: impl Into<String>) -> Self {
        self.to_entity = value.into();
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_field(mut self, value: impl Into<String>) -> Self {
        self.to_field = value.into();
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_alias(mut self, value: impl Into<String>) -> Self {
        self.to_alias = value.into();
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_limit(mut self, value: i32) -> Self {
        self.to_limit = value;
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_order_by(mut self, value: impl Into<String>) -> Self {
        self.to_order_by = value.into();
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_filter(mut self, filter: AdvanceFilter) -> Self {
        self.to_filters.push(filter);
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn to_filters(mut self, filters: impl IntoIterator<Item = AdvanceFilter>) -> Self {
        self.to_filters.extend(filters);
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn from_entity(mut self, value: impl Into<String>) -> Self {
        self.from_entity = value.into();
        self
    }

    #[allow(clippy::wrong_self_convention)]
    pub fn from_field(mut self, value: impl Into<String>) -> Self {
        self.from_field = value.into();
        self
    }

    pub fn build(self) -> Join {
        Join {
            r#type: self.r#type,
            field_relation: Some(FieldRelation {
                to: Some(EntityFieldTo {
                    entity: self.to_entity,
                    field: self.to_field,
                    alias: self.to_alias,
                    limit: self.to_limit,
                    order_by: self.to_order_by,
                    filters: self.to_filters,
                }),
                from: Some(EntityFieldFrom {
                    entity: self.from_entity,
                    field: self.from_field,
                }),
            }),
        }
    }
}