Return Either HTML or JSON From Actix Web Handler

Question

I would like all of my routes to return Json instead of HTML when requested.

For example, when /index.json is requested, it should return the object that the /index html response would be built with.

I'm currently handling this with a "tail match" in the routing macro on line 11:

  5 #[derive(Serialize)]
  6 struct FollowerPresenter {
  7     follower_name: String,
  8     followee_name: String,
  9 }
 10
 11 #[get("/index{tail:.*}")]
 12 async fn index(
 13     mime: web::Path<String>,
 14     template: web::Data<tera::Tera>,
 15 ) -> Result<HttpResponse, Error> {
 16     let presenter = FollowerPresenter {
 17         follower_name: "Jill".into(),
 18         followee_name: "Jim".into(),
 19     };
 20
 21     match mime.as_str() {
 22         "" | "/" => {
 23             let body = template
 24                 .render("index.html", &Context::from_serialize(&presenter).unwrap())
 25                 .map_err(|_| error::ErrorInternalServerError("Template error"))?;
 26
 27             Ok(HttpResponse::Ok().content_type("text/html").body(body))
 28         }
 29         ".json" => Ok(HttpResponse::Ok().json(presenter)),
 30         _ => Err(error::ErrorNotFound("Resource Not Found")),
 31     }
 32 }
 33
 34 #[actix_web::main]
 35 async fn main() -> std::io::Result<()> {
 36     HttpServer::new(|| {
 37         let tera = Tera::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/views/**/*")).unwrap();
 38
 39         App::new().data(tera).service(index)
 40     })
 41     .bind("127.0.0.1:3000")?
 42     .run()
 43     .await
 44 }

There's got to be a way, with middleware or something, to avoid putting the entire control structure on lines 21-30 in each handler.

Njuguna Mureithi Njuguna Mureithi · Accepted Answer · 2021-02-16T11:44:03

Well your question (and my answer too) relies on the req.query("tail") and can be improved by checking the url itself (where you can use str::ends_with).

Here is a working solution based on Responder.

use actix_http::{Error, Response};
use actix_web::*;
use futures_util::future::{err, ok, Ready};
use serde::Serialize;
use tera::{Context, Tera};

struct MyResponder<P: Serialize, T: Into<String>> {
    presenter: P,
    template: T,
}

impl<P: Serialize, T: Into<String>> Responder for MyResponder<P, T> {
    type Error = Error;
    type Future = Ready<Result<Response, Error>>;

    fn respond_to(self, req: &HttpRequest) -> Self::Future {
        let mime = req.match_info().query("tail");
        let template = req.app_data::<web::Data<tera::Tera>>().unwrap();
        let presenter = serde_json::to_value(&self.presenter).unwrap();
        match mime {
            "" | "/" => {
                let body = template
                    .render(
                        &self.template.into(),
                        &Context::from_serialize(&presenter).unwrap(),
                    )
                    .unwrap();
                ok(HttpResponse::Ok().content_type("text/html").body(body))
            }
            ".json" => ok(HttpResponse::Ok().json(&presenter)),
            _ => err(error::ErrorNotFound("Resource Not Found")),
        }
    }
}

#[derive(Serialize)]
struct FollowerPresenter {
    follower_name: String,
    followee_name: String,
}

#[get("/index{tail:.*}")]
async fn index() -> impl Responder {
    let presenter = FollowerPresenter {
        follower_name: "Jill".into(),
        followee_name: "Jim".into(),
    };

    MyResponder {
        presenter,
        template: "index.html",
    }
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        let tera = Tera::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/views/**/*")).unwrap();
        App::new().data(tera).service(index)
    })
    .bind("127.0.0.1:3000")?
    .run()
    .await
}

#[cfg(test)]
mod tests {
    use super::*;
    use actix_web::{body::Body, test, App};
    use serde_json::json;

    #[actix_rt::test]
    async fn test_json_get() {
        let tera = Tera::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/views/**/*")).unwrap();
        let mut app = test::init_service(App::new().data(tera).service(index)).await;
        let req = test::TestRequest::with_uri("/index.json").to_request();
        let mut resp = test::call_service(&mut app, req).await;
        let body = resp.take_body();
        let body = body.as_ref().unwrap();
        assert!(resp.status().is_success());
        assert_eq!(
            &Body::from(json!({"follower_name":"Jill", "followee_name": "Jim" })), // or serde.....
            body
        );
    }
    #[actix_rt::test]
    #[should_panic] /// Template doesnt exist
    async fn test_web_get() {
        let tera = Tera::new(concat!(env!("CARGO_MANIFEST_DIR"), "/src/views/**/*")).unwrap();
        let mut app = test::init_service(App::new().data(tera).service(index)).await;
        let req = test::TestRequest::with_uri("/index").to_request();
        let _resp = test::call_service(&mut app, req).await;

    }
}

Running the tests yields:

running 2 tests
test tests::test_json_get ... ok
test tests::test_web_get ... ok

test result: ok. 2 passed; 0 failed; 0 ignored; 0 measured; 0 filtered out

Return Either HTML or JSON From Actix Web Handler

1 Answers