rbp_server/analysis/
handlers.rs

1use super::API;
2use rbp_cards::*;
3use rbp_core::*;
4use rbp_gameplay::*;
5use actix_web::HttpResponse;
6use actix_web::Responder;
7use actix_web::web;
8
9pub async fn replace_obs(api: web::Data<API>, req: web::Json<ReplaceObs>) -> impl Responder {
10    match Observation::try_from(req.obs.as_str()) {
11        Err(_) => HttpResponse::BadRequest().body("invalid observation format"),
12        Ok(obs) => match api.replace_obs(obs).await {
13            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
14            Ok(new) => HttpResponse::Ok().json(new.to_string()),
15        },
16    }
17}
18pub async fn exp_wrt_str(api: web::Data<API>, req: web::Json<SetStreets>) -> impl Responder {
19    match Street::try_from(req.street.as_str()) {
20        Err(_) => HttpResponse::BadRequest().body("invalid street format"),
21        Ok(street) => match api.exp_wrt_str(street).await {
22            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
23            Ok(row) => HttpResponse::Ok().json(row),
24        },
25    }
26}
27pub async fn exp_wrt_abs(api: web::Data<API>, req: web::Json<ReplaceAbs>) -> impl Responder {
28    match Abstraction::try_from(req.wrt.as_str()) {
29        Err(_) => HttpResponse::BadRequest().body("invalid abstraction format"),
30        Ok(abs) => match api.exp_wrt_abs(abs).await {
31            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
32            Ok(row) => HttpResponse::Ok().json(row),
33        },
34    }
35}
36pub async fn exp_wrt_obs(api: web::Data<API>, req: web::Json<RowWrtObs>) -> impl Responder {
37    match Observation::try_from(req.obs.as_str()) {
38        Err(_) => HttpResponse::BadRequest().body("invalid observation format"),
39        Ok(obs) => match api.exp_wrt_obs(obs).await {
40            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
41            Ok(row) => HttpResponse::Ok().json(row),
42        },
43    }
44}
45pub async fn nbr_any_wrt_abs(api: web::Data<API>, req: web::Json<ReplaceAbs>) -> impl Responder {
46    match Abstraction::try_from(req.wrt.as_str()) {
47        Err(_) => HttpResponse::BadRequest().body("invalid abstraction format"),
48        Ok(abs) => match api.nbr_any_wrt_abs(abs).await {
49            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
50            Ok(row) => HttpResponse::Ok().json(row),
51        },
52    }
53}
54pub async fn nbr_abs_wrt_abs(api: web::Data<API>, req: web::Json<ReplaceOne>) -> impl Responder {
55    let wrt = Abstraction::try_from(req.wrt.as_str());
56    let abs = Abstraction::try_from(req.abs.as_str());
57    match (wrt, abs) {
58        (Err(_), _) => HttpResponse::BadRequest().body("invalid abstraction format"),
59        (_, Err(_)) => HttpResponse::BadRequest().body("invalid abstraction format"),
60        (Ok(wrt), Ok(abs)) => match api.nbr_abs_wrt_abs(wrt, abs).await {
61            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
62            Ok(row) => HttpResponse::Ok().json(row),
63        },
64    }
65}
66pub async fn nbr_obs_wrt_abs(api: web::Data<API>, req: web::Json<ReplaceRow>) -> impl Responder {
67    let wrt = Abstraction::try_from(req.wrt.as_str());
68    let obs = Observation::try_from(req.obs.as_str());
69    match (wrt, obs) {
70        (Err(_), _) => HttpResponse::BadRequest().body("invalid abstraction format"),
71        (_, Err(_)) => HttpResponse::BadRequest().body("invalid observation format"),
72        (Ok(abs), Ok(obs)) => match api.nbr_obs_wrt_abs(abs, obs).await {
73            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
74            Ok(rows) => HttpResponse::Ok().json(rows),
75        },
76    }
77}
78pub async fn kfn_wrt_abs(api: web::Data<API>, req: web::Json<ReplaceAbs>) -> impl Responder {
79    match Abstraction::try_from(req.wrt.as_str()) {
80        Err(_) => HttpResponse::BadRequest().body("invalid abstraction format"),
81        Ok(abs) => match api.kfn_wrt_abs(abs).await {
82            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
83            Ok(rows) => HttpResponse::Ok().json(rows),
84        },
85    }
86}
87pub async fn knn_wrt_abs(api: web::Data<API>, req: web::Json<ReplaceAbs>) -> impl Responder {
88    match Abstraction::try_from(req.wrt.as_str()) {
89        Err(_) => HttpResponse::BadRequest().body("invalid abstraction format"),
90        Ok(abs) => match api.knn_wrt_abs(abs).await {
91            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
92            Ok(rows) => HttpResponse::Ok().json(rows),
93        },
94    }
95}
96pub async fn kgn_wrt_abs(api: web::Data<API>, req: web::Json<ReplaceAll>) -> impl Responder {
97    match Abstraction::try_from(req.wrt.as_str()) {
98        Err(_) => HttpResponse::BadRequest().body("invalid abstraction format"),
99        Ok(wrt) => {
100            let obs = req
101                .neighbors
102                .iter()
103                .map(|string| string.as_str())
104                .map(Observation::try_from)
105                .filter_map(|result| result.ok())
106                .filter(|o| o.street() == wrt.street())
107                .chain((0..).map(|_| Observation::from(wrt.street())))
108                .take(5)
109                .collect::<Vec<_>>();
110            match api.kgn_wrt_abs(wrt, obs).await {
111                Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
112                Ok(rows) => HttpResponse::Ok().json(rows),
113            }
114        }
115    }
116}
117pub async fn hst_wrt_abs(api: web::Data<API>, req: web::Json<AbsHist>) -> impl Responder {
118    match Abstraction::try_from(req.abs.as_str()) {
119        Err(_) => HttpResponse::BadRequest().body("invalid abstraction format"),
120        Ok(abs) => match api.hst_wrt_abs(abs).await {
121            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
122            Ok(rows) => HttpResponse::Ok().json(rows),
123        },
124    }
125}
126pub async fn hst_wrt_obs(api: web::Data<API>, req: web::Json<ObsHist>) -> impl Responder {
127    match Observation::try_from(req.obs.as_str()) {
128        Err(_) => HttpResponse::BadRequest().body("invalid observation format"),
129        Ok(obs) => match api.hst_wrt_obs(obs).await {
130            Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
131            Ok(rows) => HttpResponse::Ok().json(rows),
132        },
133    }
134}
135pub async fn blueprint(api: web::Data<API>, req: web::Json<GetPolicy>) -> impl Responder {
136    let hero = Turn::try_from(req.turn.as_str());
137    let seen = Observation::try_from(req.seen.as_str());
138    let path = req
139        .past
140        .iter()
141        .map(|string| string.as_str())
142        .map(Action::try_from)
143        .collect::<Result<Vec<_>, _>>();
144    match (hero, seen, path) {
145        (Ok(hero), Ok(seen), Ok(path)) => match Partial::try_build(hero, seen, path) {
146            Err(e) => HttpResponse::BadRequest().body(format!("invalid action sequence: {}", e)),
147            Ok(recall) => match api.policy(recall).await {
148                Err(e) => HttpResponse::InternalServerError().body(e.to_string()),
149                Ok(Some(strategy)) => HttpResponse::Ok().json(strategy),
150                Ok(None) => HttpResponse::Ok().json(serde_json::Value::Null),
151            },
152        },
153        _ => HttpResponse::BadRequest().body("invalid recall format"),
154    }
155}
rbp_server/analysis/handlers.rs

rbp_server/analysis/
handlers.rs
