path: root/dichroism/src/main.rs

use actix_web::{web, App, Error, HttpRequest, HttpResponse, HttpServer, Responder};
use futures::future::{ready, Ready};
use listenfd::ListenFd;
use serde::Serialize;

#[derive(Serialize)]
struct Product {
    id: u32,
    name: String,
    quantity: i32,
    cents: u32,
    img_path: String,
    description: String,
}

impl Responder for Product {
    type Error = Error;
    type Future = Ready<Result<HttpResponse, Error>>;

    fn respond_to(self, _req: &HttpRequest) -> Self::Future {
        let body = serde_json::to_string(&self).unwrap();

        ready(Ok(HttpResponse::Ok()
            .content_type("application/json")
            .body(body)))
    }
}

async fn products() -> impl Responder {
    Product {
        id: 1,
        name: "Beach Box".to_string(),
        quantity: 3,
        cents: 1100,
        img_path: "/beach_box.jpg".to_string(),
        description: "It's a beach in a box".to_string(),
    }
}

async fn greet(req: HttpRequest) -> impl Responder {
    let name = req.match_info().get("name").unwrap_or("World");
    format!("Hello {}!", &name)
}

async fn index() -> impl Responder {
    "Hello, this is an API. If you're looking for the web app, try the top-level domain at port 443.".to_string()
}

#[actix_rt::main]
async fn main() -> std::io::Result<()> {
    let mut listenfd = ListenFd::from_env();
    let mut server = HttpServer::new(|| {
        App::new()
            .route("/", web::get().to(index))
            .route("/{name}", web::get().to(greet))
            .route("/products", web::get().to(products))
    });

    server = if let Some(l) = listenfd.take_tcp_listener(0).unwrap() {
        server.listen(l)?
    } else {
        server.bind("127.0.0.1:8000")?
    };
    server.run().await
}