rust_store 0.2.5

A quick and easy cache database for you to use!
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

use std::fmt::Display;

use crate::https::State;
use better_file_maker;
use rocket::get;
use rocket_contrib::json::Json;
use serde::Serialize;
use txt_writer;

use super::functions::path_second;

#[derive(Serialize)]
pub struct Data {
    pub error: String,
}

pub struct AddDataFunc();

impl AddDataFunc {
    fn make_file_struct<T: Display, E: Display, F: Display>(
        &self,
        data: T,
        path: E,
        data_name: F,
    ) -> Data {
        let file_error =
            txt_writer::WriteData {}.replace(data, format!("{}/{}.txt", path, data_name));
        match file_error {
            Err(e) => Data {
                error: e.to_string(),
            },
            Ok(_) => Data {
                error: "Success".to_owned(),
            },
        }
    }
    pub fn core<T: Display, E: Display, F: Display>(
        &self,
        final_path: T,
        data_name: E,
        data: F,
        null_key: String,
    ) -> Data {
        let file_error =
            txt_writer::ReadData {}.read(format!("{}/{}.txt", &final_path, &data_name));
        match file_error {
            Ok(read_data) => {
                if read_data[0] == null_key {
                    AddDataFunc {}.make_file_struct(data, final_path, data_name)
                } else {
                    let error = txt_writer::WriteData {}
                        .add(data, format!("{}/{}.txt", final_path, data_name));
                    match error {
                        Ok(_) => Data {
                            error: "Success".to_owned(),
                        },
                        Err(e) => Data {
                            error: e.to_string(),
                        },
                    }
                }
            }
            Err(_) => {
                let writing_error = txt_writer::WriteData {}
                    .replace(&data, format!("{}/{}.txt", &final_path, &data_name));
                match writing_error {
                    Ok(_) => Data {
                        error: "Success".to_owned(),
                    },
                    Err(_) => {
                        let file_error = better_file_maker::make_folders(&final_path);
                        match file_error {
                            Ok(_) => AddDataFunc {}.make_file_struct(data, final_path, data_name),

                            Err(e) => Data {
                                error: e.to_string(),
                            },
                        }
                    }
                }
            }
        }
    }
}

#[get("/add/<path>/<data_name>/<data>/<api_key>")]
pub fn add(
    path: String,
    data_name: String,
    data: String,
    api_key: String,
    api_state: State<crate::StateData>,
) -> Json<Data> {
    if api_key != api_state.api_key {
        return Json(Data {
            error: "Not authorized".to_owned(),
        });
    }
    let final_path = path_second(path, api_state.data_storage_location.clone());
    Json(AddDataFunc {}.core(final_path, data_name, data, api_state.null.clone()))
}