splitterrust_db 0.1.0

The database implementation for splitterrust, a collections of utilities written in rust for the splittermond P&P.
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
119
120
121
122
123
124
125
126
127
128
129
130

/*
This is the spell data with the corresponding schools linked in pretty and
german. The serialization will skip all None fields and will rename each field
to the german match.
*/
use serde::{
    Deserialize,
    Serialize,
};

use crate::models::schools::Schools as _Schools;
use crate::models::spell::Spell as _Spell;

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Spell {
    #[serde(rename = "Dauer")]
    pub cast_duration:      String,
    #[serde(rename = "Optionen")]
    pub options:            Vec<String>,
    #[serde(rename = "Reichweite")]
    pub range:              String,
    #[serde(rename = "Schwierigkeit")]
    pub difficulty:         String,
    #[serde(rename = "Typus")]
    pub typus:              String,
    #[serde(rename = "Verstärkt")]
    pub enforced:           String,
    #[serde(rename = "Wirkung")]
    pub effect:             String,
    #[serde(rename = "Wirkungsdauer")]
    pub duration_of_effect: String,
    #[serde(rename = "Zauberkosten")]
    pub cost:               String,
    #[serde(rename = "Name")]
    pub name:               String,
    #[serde(rename = "Schulen")]
    pub schools:            Schools,
}

#[derive(Default, Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct Schools {
    #[serde(rename = "Feuermagie", skip_serializing_if = "Option::is_none")]
    pub fire:          Option<i32>,
    #[serde(rename = "Schutzmagie", skip_serializing_if = "Option::is_none")]
    pub protection:    Option<i32>,
    #[serde(rename = "Lichtmagie", skip_serializing_if = "Option::is_none")]
    pub light:         Option<i32>,
    #[serde(rename = "Erkenntnismagie", skip_serializing_if = "Option::is_none")]
    pub detection:     Option<i32>,
    #[serde(rename = "Stärkungsmagie", skip_serializing_if = "Option::is_none")]
    pub strengthening: Option<i32>,
    #[serde(rename = "Verwandlungsmagie", skip_serializing_if = "Option::is_none")]
    pub metamorphism:  Option<i32>,
    #[serde(rename = "Bannmagie", skip_serializing_if = "Option::is_none")]
    pub bann:          Option<i32>,
    #[serde(rename = "Illusionsmagie", skip_serializing_if = "Option::is_none")]
    pub illusion:      Option<i32>,
    #[serde(rename = "Bewegungsmagie", skip_serializing_if = "Option::is_none")]
    pub movement:      Option<i32>,
    #[serde(rename = "Windmagie", skip_serializing_if = "Option::is_none")]
    pub wind:          Option<i32>,
    #[serde(rename = "Heilungsmagie", skip_serializing_if = "Option::is_none")]
    pub heal:          Option<i32>,
    #[serde(rename = "Todesmagie", skip_serializing_if = "Option::is_none")]
    pub death:         Option<i32>,
    #[serde(rename = "Schicksalsmagie", skip_serializing_if = "Option::is_none")]
    pub fate:          Option<i32>,
    #[serde(rename = "Naturmagie", skip_serializing_if = "Option::is_none")]
    pub nature:        Option<i32>,
    #[serde(rename = "Beherrschungsmagie", skip_serializing_if = "Option::is_none")]
    pub control:       Option<i32>,
    #[serde(rename = "Kampfmagie", skip_serializing_if = "Option::is_none")]
    pub fight:         Option<i32>,
    #[serde(rename = "Wassermagie", skip_serializing_if = "Option::is_none")]
    pub water:         Option<i32>,
    #[serde(rename = "Schattenmagie", skip_serializing_if = "Option::is_none")]
    pub shadow:        Option<i32>,
    #[serde(rename = "Felsmagie", skip_serializing_if = "Option::is_none")]
    pub earth:         Option<i32>,
}

impl Spell {
    pub fn from_left_join(data: (_Spell, _Schools)) -> Spell {
        let schools = Schools {
            fire:          data.1.fire,
            protection:    data.1.protection,
            light:         data.1.light,
            detection:     data.1.detection,
            strengthening: data.1.strengthening,
            metamorphism:  data.1.metamorphism,
            bann:          data.1.bann,
            illusion:      data.1.illusion,
            movement:      data.1.movement,
            wind:          data.1.wind,
            heal:          data.1.heal,
            death:         data.1.death,
            fate:          data.1.fate,
            nature:        data.1.nature,
            control:       data.1.control,
            fight:         data.1.fight,
            water:         data.1.water,
            shadow:        data.1.shadow,
            earth:         data.1.earth,
        };

        Spell {
            name:               data.0.name,
            duration_of_effect: data.0.duration_of_effect,
            options:            data.0.options,
            range:              data.0.range,
            difficulty:         data.0.difficulty,
            typus:              data.0.typus,
            enforced:           data.0.enforced,
            effect:             data.0.effect,
            cast_duration:      data.0.cast_duration,
            cost:               data.0.cost,
            schools:            schools,
        }
    }

    pub fn to_json_pretty(self) -> String {
        use serde_json::json;
        serde_json::to_string_pretty(&json!(self)).unwrap()
    }

    pub fn to_json(self) -> String {
        use serde_json::json;
        json!(self).to_string()
    }
}