567 lines
19 KiB
Rust
567 lines
19 KiB
Rust
// use std::convert::Infallible;
|
|
// use std::collections::HashMap;
|
|
use warp::{
|
|
// http::{StatusCode},
|
|
http::{method::Method, HeaderMap, HeaderValue},
|
|
Reply, Rejection,
|
|
};
|
|
use reqenv::ReqEnv;
|
|
// use app_env::profile::Profile;
|
|
// use app_env::config::Config;
|
|
use kloud::{
|
|
defs::{
|
|
KloudQueryConfigFilters,
|
|
},
|
|
};
|
|
use clds::clouds::defs::{Cloud};
|
|
use crate::defs::{DataDBs}; // ,CollsData};
|
|
use clds::clouds::on_clouds::{on_cloud_req,on_cloud_name_req,get_cloud_check};
|
|
|
|
pub async fn cloud_req(reqname: &str,cloud: &Cloud,reqenv: &ReqEnv,opts: &KloudQueryConfigFilters) -> String {
|
|
let mut result: String;
|
|
if opts.grp.is_empty() {
|
|
result = on_cloud_req(&reqname,&cloud,&reqenv,&opts.tsksrvcs,&opts.srvrs,&opts.cld).await;
|
|
} else if opts.name.is_empty() {
|
|
let source = format!("{}/{}",&opts.cld,&opts.grp);
|
|
result = on_cloud_name_req(&reqname,&cloud,&reqenv,&opts.tsksrvcs,&opts.srvrs,&source).await;
|
|
} else {
|
|
let source = format!("{}/{}/{}",&opts.cld,&opts.grp,&opts.name);
|
|
result = on_cloud_name_req(&reqname,&cloud,&reqenv,&opts.tsksrvcs,&opts.srvrs,&source).await;
|
|
}
|
|
if opts.tsksrvcs.contains("liveness") {
|
|
result = format!("{}:{}{}:{}{}",r#"{"req""#,&result,r#","liveness""#,get_cloud_check(&reqenv).await,r#"}"#);
|
|
}
|
|
match reqname {
|
|
"config" => {
|
|
result.to_owned()
|
|
},
|
|
"status" => {
|
|
result.to_owned()
|
|
},
|
|
"provision" => {
|
|
result.to_owned()
|
|
},
|
|
"liveness" => {
|
|
result.to_owned()
|
|
},
|
|
_ => {
|
|
result.to_owned()
|
|
}
|
|
}
|
|
}
|
|
pub async fn config (
|
|
opts: KloudQueryConfigFilters,
|
|
header: HeaderMap<HeaderValue>,
|
|
method: Method,
|
|
// user: UserCtx,
|
|
db: DataDBs,
|
|
cloud: Cloud,
|
|
prfx: String,
|
|
// path: warp::path::FullPath, headers: warp::http::HeaderMap
|
|
) -> Result<impl Reply, Rejection> {
|
|
// dbg!("{:#?}",&db);
|
|
// dbg!("{:#?}",&header);
|
|
// dbg!("{:#?}",&opts);
|
|
let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/config", "config", &prfx);
|
|
// get_pkgs_vers(&mut cloud).await?;
|
|
|
|
// cloud.env.listhosts = String::from(listhosts);
|
|
// if let Some(lang_str) = header.get("accept-language") {
|
|
// println!("{:?}",&lang_str);
|
|
// }
|
|
// println!("User: {} | {}",&user.user_id,&user.token);
|
|
|
|
// println!("LANG: {}",language);
|
|
// if prfx.as_str() == "ta" {
|
|
// let cur = db.colls.ta.entries.read();
|
|
// }
|
|
// let allow_origin = reqenv.websrvr().allow_origin;
|
|
// let result = cloud_req("config",&cloud,&reqenv,&opts).await;
|
|
// println!("Result: {}",&result);
|
|
// return Ok(warp::http::Response::builder()
|
|
// .body(result.to_string())
|
|
// .into_response())
|
|
// ;
|
|
match reqenv.user_authentication().await {
|
|
Ok(_auth) => {
|
|
// dbg!("auth: {}",&auth);
|
|
match prfx.as_str() {
|
|
"kloud" => {
|
|
let result = cloud_req("config",&cloud,&reqenv,&opts).await;
|
|
// println!("Result: {}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
},
|
|
"ta" => {
|
|
/* let data = CollsData::get_ta_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
"tp" => {
|
|
// let result = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
/* let data = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
_ => {
|
|
//let result="";
|
|
let result = format!("list for '{}' undefined",&prfx);
|
|
// (AuthError::UserNotFoundError.to_string())
|
|
println!("{}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
},
|
|
Err(e) => {
|
|
let result = format!("Error: no credentials found");
|
|
println!("{}",e);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
}
|
|
pub async fn provision (
|
|
opts: KloudQueryConfigFilters,
|
|
header: HeaderMap<HeaderValue>,
|
|
method: Method,
|
|
// user: UserCtx,
|
|
db: DataDBs,
|
|
cloud: Cloud,
|
|
prfx: String,
|
|
// path: warp::path::FullPath, headers: warp::http::HeaderMap
|
|
) -> Result<impl Reply, Rejection> {
|
|
// dbg!("{:#?}",&db);
|
|
// dbg!("{:#?}",&header);
|
|
// dbg!("{:#?}",&opts);
|
|
let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/provision", "provision", &prfx);
|
|
// if let Some(lang_str) = header.get("accept-language") {
|
|
// println!("{:?}",&lang_str);
|
|
// }
|
|
// println!("User: {} | {}",&user.user_id,&user.token);
|
|
|
|
// println!("LANG: {}",language);
|
|
// if prfx.as_str() == "ta" {
|
|
// let cur = db.colls.ta.entries.read();
|
|
// }
|
|
// let allow_origin = reqenv.websrvr().allow_origin;
|
|
// let test = true;
|
|
// if test == true {
|
|
let result = cloud_req("provision",&cloud,&reqenv,&opts).await;
|
|
println!("Result: {}",&result);
|
|
// return Ok(warp::http::Response::builder()
|
|
// .body(result.to_string())
|
|
// .into_response());
|
|
// } else {
|
|
match reqenv.user_authentication().await {
|
|
Ok(_auth) => {
|
|
// dbg!("auth: {}",&auth);
|
|
match prfx.as_str() {
|
|
"kloud" => {
|
|
let result = cloud_req("provision",&cloud,&reqenv,&opts).await;
|
|
println!("Result: {}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
},
|
|
"ta" => {
|
|
/* let data = CollsData::get_ta_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
"tp" => {
|
|
// let result = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
/* let data = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
_ => {
|
|
//let result="";
|
|
let result = format!("list for '{}' undefined",&prfx);
|
|
// (AuthError::UserNotFoundError.to_string())
|
|
println!("{}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
},
|
|
Err(e) => {
|
|
let result = format!("Error: no credentials found");
|
|
println!("{}",e);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
// }
|
|
}
|
|
pub async fn status (
|
|
opts: KloudQueryConfigFilters,
|
|
header: HeaderMap<HeaderValue>,
|
|
method: Method,
|
|
// user: UserCtx,
|
|
db: DataDBs,
|
|
cloud: Cloud,
|
|
prfx: String,
|
|
// path: warp::path::FullPath, headers: warp::http::HeaderMap
|
|
) -> Result<impl Reply, Rejection> {
|
|
// dbg!("{:#?}",&db);
|
|
// dbg!("{:#?}",&header);
|
|
// dbg!("{:#?}",&opts);
|
|
let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/status", "status", &prfx);
|
|
// if let Some(lang_str) = header.get("accept-language") {
|
|
// println!("{:?}",&lang_str);
|
|
// }
|
|
// println!("User: {} | {}",&user.user_id,&user.token);
|
|
|
|
// println!("LANG: {}",language);
|
|
// if prfx.as_str() == "ta" {
|
|
// let cur = db.colls.ta.entries.read();
|
|
// }
|
|
// let allow_origin = reqenv.websrvr().allow_origin;
|
|
// let result = cloud_req("status",&cloud,&reqenv,&opts).await;
|
|
// println!("Result: {}",&result);
|
|
// return Ok(warp::http::Response::builder()
|
|
// .body(result.to_string())
|
|
// .into_response());
|
|
match reqenv.user_authentication().await {
|
|
Ok(_auth) => {
|
|
// dbg!("auth: {}",&auth);
|
|
match prfx.as_str() {
|
|
"kloud" => {
|
|
let result = cloud_req("status",&cloud,&reqenv,&opts).await;
|
|
println!("Result: {}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
},
|
|
"ta" => {
|
|
/* let data = CollsData::get_ta_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
"tp" => {
|
|
// let result = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
/* let data = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
_ => {
|
|
//let result="";
|
|
let result = format!("list for '{}' undefined",&prfx);
|
|
// (AuthError::UserNotFoundError.to_string())
|
|
println!("{}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
},
|
|
Err(e) => {
|
|
let result = format!("Error: no credentials found");
|
|
println!("{}",e);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
}
|
|
pub async fn liveness (
|
|
opts: KloudQueryConfigFilters,
|
|
header: HeaderMap<HeaderValue>,
|
|
method: Method,
|
|
// user: UserCtx,
|
|
db: DataDBs,
|
|
cloud: Cloud,
|
|
prfx: String,
|
|
// path: warp::path::FullPath, headers: warp::http::HeaderMap
|
|
) -> Result<impl Reply, Rejection> {
|
|
// dbg!("{:#?}",&db);
|
|
// dbg!("{:#?}",&header);
|
|
// dbg!("{:#?}",&opts);
|
|
let reqenv = ReqEnv::new(db.app, db.auth, header, method, "/liveness", "liveness", &prfx);
|
|
// if let Some(lang_str) = header.get("accept-language") {
|
|
// println!("{:?}",&lang_str);
|
|
// }
|
|
// println!("User: {} | {}",&user.user_id,&user.token);
|
|
|
|
// println!("LANG: {}",language);
|
|
// if prfx.as_str() == "ta" {
|
|
// let cur = db.colls.ta.entries.read();
|
|
// }
|
|
// let allow_origin = reqenv.websrvr().allow_origin;
|
|
// let test = true;
|
|
// if test == true {
|
|
// let result = cloud_req("liveness",&cloud,&reqenv,&opts).await;
|
|
// println!("Result: {}",&result);
|
|
// return Ok(warp::http::Response::builder()
|
|
// .body(result.to_string())
|
|
// .into_response());
|
|
// } else {
|
|
match reqenv.user_authentication().await {
|
|
Ok(_auth) => {
|
|
// dbg!("auth: {}",&auth);
|
|
match prfx.as_str() {
|
|
"kloud" => {
|
|
let result = cloud_req("liveness",&cloud,&reqenv,&opts).await;
|
|
println!("Result: {}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
},
|
|
"ta" => {
|
|
/* let data = CollsData::get_ta_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TopographicAnatomy> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_ta_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
"tp" => {
|
|
// let result = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
/* let data = CollsData::get_tp_entries(db.colls.clone()).await;
|
|
let data_out: Vec<TrackingPoint> = data.iter().enumerate().filter(|(idx,(itm,_))|{
|
|
let mut skip = false;
|
|
if !opts.id.is_empty() && !itm.contains(&opts.id) { skip = true; }
|
|
if opts.start > 0 && idx < &(opts.start as usize) { skip = true; }
|
|
if opts.end > 0 && idx > &(opts.end as usize) { skip = true; }
|
|
!skip
|
|
}).map(|(_,(_,value))| value).cloned().collect();
|
|
*/
|
|
let data_out: Vec<String> = Vec::new();
|
|
let result = serde_json::to_string(&data_out).unwrap_or_else(|_| String::from(""));
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&CollsData::get_tp_entries(db.colls.clone()).await),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
// Ok(warp::reply::json(&result))
|
|
*/
|
|
},
|
|
_ => {
|
|
//let result="";
|
|
let result = format!("list for '{}' undefined",&prfx);
|
|
// (AuthError::UserNotFoundError.to_string())
|
|
println!("{}",&result);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
// warp::http::Response::new(body),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
},
|
|
Err(e) => {
|
|
let result = format!("Error: no credentials found");
|
|
println!("{}",e);
|
|
Ok(warp::http::Response::builder()
|
|
.body(result.to_string())
|
|
.into_response())
|
|
/*
|
|
Ok(warp::reply::with_header(
|
|
// warp::reply::json(&""),
|
|
warp::http::Response::new(result),
|
|
"Access-Control-Allow-Origin",
|
|
&allow_origin))
|
|
*/
|
|
},
|
|
}
|
|
// }
|
|
} |