wordval-web 1.0.13

Wordval web layer: router, middleware, extractors, responses, session-based authentication
Documentation
//! 角色校验中间件

use super::CurrentUser;
use axum::{body::Body, extract::Request, response::Response};
use std::future::Future;
use std::pin::Pin;
use std::task::{Context, Poll};
use tower::{Layer, Service};
use wordval_core::api::ApiError;

#[derive(Clone)]
/// 角色拦截层——拥有任意一个角色即放行
pub struct RequireRoleLayer {
    pub roles: Vec<String>,
}

impl RequireRoleLayer {
    pub fn any(roles: Vec<String>) -> Self {
        Self { roles }
    }
}

impl<S> Layer<S> for RequireRoleLayer {
    type Service = RequireRoleService<S>;

    fn layer(&self, inner: S) -> Self::Service {
        RequireRoleService {
            inner,
            roles: self.roles.clone(),
        }
    }
}

#[derive(Clone)]
/// 角色拦截服务——校验用户是否拥有所需角色
pub struct RequireRoleService<S> {
    /// 下游服务
    inner: S,
    /// 所需角色列表
    roles: Vec<String>,
}

impl<S> Service<Request<Body>> for RequireRoleService<S>
where
    S: Service<Request<Body>, Response = Response> + Clone + Send + 'static,
    S::Future: Send + 'static,
{
    type Response = S::Response;
    type Error = S::Error;
    type Future = Pin<Box<dyn Future<Output = Result<Self::Response, Self::Error>> + Send>>;

    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
        self.inner.poll_ready(cx)
    }

    fn call(&mut self, req: Request<Body>) -> Self::Future {
        // 借用 extensions 判定,避免每请求克隆整个 CurrentUser(含 roles/permissions Vec)
        let rejection: Option<ApiError> = match req.extensions().get::<CurrentUser>() {
            Some(session) => {
                // 管理员角色视为拥有全部角色(is_authorized 语义统一)
                if session.is_admin_user() || self.roles.iter().any(|r| session.has_role(r)) {
                    None
                } else {
                    Some(ApiError::forbidden("无权限访问,角色不足"))
                }
            }
            None => Some(ApiError::unauthorized("未认证,请先登录")),
        };

        match rejection {
            Some(err) => {
                let resp = super::error_response(err);
                Box::pin(async move { Ok(resp) })
            }
            None => {
                let replacement = self.inner.clone();
                let mut inner = std::mem::replace(&mut self.inner, replacement);
                Box::pin(async move { inner.call(req).await })
            }
        }
    }
}