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

use std::collections::HashMap;
use std::fmt::Display;

use rocket::{get, State};
use rocket_contrib::json::Json;
use serde::Serialize;
use crate::https::routes::cashe::key_val_store_read::RAM_STORE;


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

pub struct KeyFunc {}

impl KeyFunc {
    pub fn main_func<T: Display, >(&self, key: T) -> Data {
        let read_error = RAM_STORE.lock();
        match read_error {
            Err(error_data) =>
                Data {
                    data: "error".to_owned(),
                    error: error_data.to_string(),
                },

            Ok(cash_data) => {
                let hash_error = HashMap::get(&cash_data, &key.to_string());
                match hash_error {
                    None => Data {
                        data: "error".to_owned(),
                        error: "no key is stored".to_owned(),
                    },
                    Some(final_data) => Data {
                        data: final_data.clone(),
                        error: "Success".to_owned(),
                    }
                }
            }
        }
    }
}

#[get("/read_key/<key>/<api_key>")]
pub fn online_func(key: String, api_key: String, api_state: State<crate::StateData>) -> Json<Data> {
    if api_key != api_state.api_key {
        return Json(Data {
            data: "error".to_owned(),
            error: "Not authorized".to_owned(),
        });
    }
    Json(KeyFunc {}.main_func(key))
}