combine_rust 0.1.4

combine for rust (only the client)
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

use serde::{Serialize, Deserialize};
use reqwest::Error;
use std::collections::HashMap;

pub use serde;
pub use serde_json;

#[derive(Serialize, Deserialize, Debug)]
pub struct CombineInfoModules {
  success: bool,
  info: Vec<String>
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CombineInfoExports {
  success: bool,
  functions: serde_json::Value
}

impl Default for CombineInfoExports {
  fn default() -> CombineInfoExports{
    CombineInfoExports {
      success: false,
      functions: serde_json::from_str("{}").unwrap()
    }
  } 
}

#[derive(Serialize, Deserialize, Debug)]
pub struct CombineResult {
  success: bool,
  data: serde_json::Value
}

#[derive(Debug)]
pub struct CombineArguments {
  arguments: Vec<serde_json::Value>
}

impl CombineArguments {
  pub fn new () -> CombineArguments {
    CombineArguments {
      arguments: vec![]
    }
  }

  pub fn push(mut self, argument: impl Serialize) -> CombineArguments {
    let _ = &self.arguments.push(serde_json::value::to_value(argument).unwrap());
    self
  }
}

async fn get_combine_info_exports (client: &reqwest::Client, host:&str, module: &str) -> Result<CombineInfoExports, Error> {
  let mut href = String::from(host);
  href.push_str("data");

  let mut map = HashMap::new();
  map.insert("module", module);
  map.insert("info", "true");

  let result_text = client.post(href).json(&map).send().await?.text().await?;
  let combine_info_exports: CombineInfoExports = serde_json::from_str(&result_text).unwrap();
  if !combine_info_exports.success {
    panic!("get_combine_info_exports failed did not return a success true")
  }
  Ok(combine_info_exports)
}

async fn run_combine_function (client: &reqwest::Client, host: &str, module: &str, export: &str, arguments: CombineArguments) -> Result<serde_json::Value, Error> {
  let json = serde_json::json!({"module": module, "export": export, "arguments": arguments.arguments});
  let mut href = String::from(host);
  href.push_str("data");

  let result_text = client.post(href).json(&json).send().await?.text().await?;
  let combine_result: CombineResult = serde_json::from_str(&result_text).unwrap();
  if !combine_result.success {
    panic!("run_combine_function failed did not return a success true")
  }
  Ok(combine_result.data)
}

async fn get_combine_value (client: &reqwest::Client, host: &str, module: &str, export: &str) -> Result<serde_json::Value, Error> {
  Ok(run_combine_function(client, host, module, export, CombineArguments::new()).await?)
}

fn unwrap_result <ContentType: serde::de::DeserializeOwned> (result: Result<serde_json::Value, reqwest::Error>) -> Result<ContentType, &'static str> {
  let result = match result {
    Ok(result) => result,
    Err(error) => return Err("Cant fetch") 
  };
  return match serde_json::from_value(result) {
    Ok(result) => Ok(result),
    Err(error) => Err("Cant parse.")
  }
}

pub struct Combine {
  host: String,
  client: reqwest::Client,
  module: String
}

impl Combine {
  pub async fn new (host: &str, module: &str) -> Combine {
    let combine = Combine {
      host: String::from(host),
      client: reqwest::Client::new(),
      module: String::from(module)
    };
    let _result = combine.get_combine_info_exports(&module).await;

    combine
  }

  pub async fn get_combine_info_exports (&self, module: &str) -> Result<CombineInfoExports, Error> {
    get_combine_info_exports(&self.client, &self.host, module).await
  }

  pub async fn run_combine_function <ContentType: serde::de::DeserializeOwned> (&self, export: &str, arguments: CombineArguments) -> Result<ContentType, &'static str> {
   unwrap_result(run_combine_function(&self.client, &self.host, &self.module, export, arguments).await)
  }

  pub async fn get_combine_value <ContentType: serde::de::DeserializeOwned>  (&self, export: &str) -> Result<ContentType, &'static str> {
    unwrap_result(get_combine_value(&self.client, &self.host, &self.module, export).await)
  }
}