Added middleware for mimetype

src/main.rs

@@ -1,15 +1,25 @@
 mod html;
 mod pages;
+mod middleware;
 
-use actix_web::{App, HttpServer};
+use actix_web::{web, App, HttpServer};
 
-use pages::{files::file, index};
+use pages::{files::file, index, projects::{projects, project}};
+use middleware::MimeType;
 
 #[actix_web::main]
 async fn main() {
     let bind_address = "0.0.0.0:8080";
     if let Ok(server) =
-        HttpServer::new(|| App::new().service(index).service(file)).bind(bind_address)
+        HttpServer::new(|| App::new()
+            .service(file)
+            .service(web::scope("")
+                .wrap(MimeType::new("text/html".to_string()))
+                .service(index)
+                .service(projects)
+                .service(project)
+            )
+        ).bind(bind_address)
     {
         match server.run().await {
             Ok(_) => {}

src/middleware/mod.rs

@@ -0,0 +1,63 @@
+use std::future::{ready, Ready};
+use actix_web::dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform};
+use actix_web::Error;
+use actix_web::http::header::{HeaderValue, CONTENT_TYPE};
+use futures_util::future::LocalBoxFuture;
+
+pub(crate) struct MimeType {
+    mime_type: String,
+}
+
+impl MimeType {
+    pub(crate) fn new(mime_type: String) -> Self {
+        Self {
+            mime_type
+        }
+    }
+}
+
+impl<S,B> Transform<S, ServiceRequest> for MimeType
+where
+    S: Service<ServiceRequest, Response=ServiceResponse<B>, Error=Error>,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Transform = MimeTypeMiddleware<S>;
+    type InitError = ();
+    type Future = Ready<Result<Self::Transform, Self::InitError>>;
+
+    fn new_transform(&self, service: S) -> Self::Future {
+        let mime_type = self.mime_type.clone();
+        ready(Ok(MimeTypeMiddleware{service, mime_type}))
+    }
+}
+
+pub(crate) struct MimeTypeMiddleware<S> {
+    service: S,
+    mime_type: String,
+}
+
+impl<S,B> Service<ServiceRequest> for MimeTypeMiddleware<S>
+where
+    S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error>,
+    S::Future: 'static,
+    B: 'static,
+{
+    type Response = ServiceResponse<B>;
+    type Error = Error;
+    type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
+
+    forward_ready!(service);
+
+    fn call(&self, req: ServiceRequest) -> Self::Future {
+        let fut = self.service.call(req);
+        let val = HeaderValue::from_str(self.mime_type.as_str()).unwrap_or_else(|_| HeaderValue::from_static("text/html"));
+        Box::pin(async move {
+            let mut res = fut.await?;
+            res.headers_mut().append(CONTENT_TYPE, val);
+            Ok(res)
+        })
+    }
+}