Newer
Older
dev::{forward_ready, Service, ServiceRequest, ServiceResponse, Transform},
Error,
};
use futures::prelude::future::LocalBoxFuture;
use std::future::{ready, Ready};
#[derive(Clone)]
pub struct AuthData {
id: String,
password: String,
_token: Option<String>,
}
impl<S, B> Transform<S, ServiceRequest> for AuthData
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
B: MessageBody + 'static,
type Error = Error;
type InitError = ();
type Transform = AuthenticatedMiddleware<S>;
type Future = Ready<Result<Self::Transform, Self::InitError>>;
fn new_transform(&self, service: S) -> Self::Future {
ready(Ok(AuthenticatedMiddleware {
service: std::rc::Rc::new(service),
auth_data: self.clone(),
}))
}
}
pub struct AuthenticatedMiddleware<S> {
#[derive(serde::Deserialize)]
struct Credentials {
id: String,
password: String,
}
async fn authenticate(req: &mut ServiceRequest, auth_data: &AuthData) -> bool {
None => match req.extract::<actix_web::web::Form<Credentials>>().await {
Ok(credentials) => {
if credentials.id == auth_data.id && credentials.password == auth_data.password {
return true;
}
return false;
}
Err(_) => false,
impl<S, B> Service<ServiceRequest> for AuthenticatedMiddleware<S>
where
S: Service<ServiceRequest, Response = ServiceResponse<B>, Error = Error> + 'static,
B: MessageBody + 'static,
type Error = Error;
type Future = LocalBoxFuture<'static, Result<Self::Response, Self::Error>>;
forward_ready!(service);
fn call(&self, req: ServiceRequest) -> Self::Future {
let service = self.service.clone();
let auth_data = self.auth_data.clone();
let mut req = req;
if let false = authenticate(&mut req, &auth_data).await {
return Ok(req.into_response(
actix_web::HttpResponse::Unauthorized()
.finish()
.map_into_right_body(),
));