apistos 0.6.0

Actix-web OpenAPI v3.0 documentation generator
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

use actix_web::dev::{AppService, HttpServiceFactory};

use actix_web::http::StatusCode;
use actix_web::{HttpRequest, HttpResponse, Responder};
use apistos_models::paths::{Header, MediaType, ParameterDefinition, Response};
use apistos_models::reference_or::ReferenceOr;
use apistos_models::{Schema, SchemaObject};
use serde_json::Value;
use std::borrow::Cow;
use std::collections::BTreeMap;
use std::fmt::Debug;

#[derive(Debug, Clone)]
pub struct Redirect {
  pub(crate) path: String,
  pub(crate) redirect: String,
  pub(crate) code: StatusCode,
  inner: actix_web::web::Redirect,
}

impl From<Redirect> for actix_web::web::Redirect {
  fn from(value: Redirect) -> Self {
    value.inner
  }
}

impl Redirect {
  /// Wrapper for [`actix_web::web::Redirect`](https://docs.rs/actix-web/*/actix_web/web/struct.Redirect.html#method.new)
  pub fn new(from: impl Into<Cow<'static, str>>, to: impl Into<Cow<'static, str>>) -> Self {
    let from: Cow<'static, str> = from.into();
    let to: Cow<'static, str> = to.into();

    Redirect {
      path: from.clone().to_string(),
      redirect: to.clone().to_string(),
      code: StatusCode::TEMPORARY_REDIRECT,
      inner: actix_web::web::Redirect::new(from, to),
    }
  }

  /// Wrapper for [`actix_web::web::Redirect`](https://docs.rs/actix-web/*/actix_web/web/struct.Redirect.html#method.to).
  pub fn to(to: impl Into<Cow<'static, str>>) -> Self {
    let to: Cow<'static, str> = to.into();
    Redirect {
      path: "/".to_owned(),
      redirect: to.clone().to_string(),
      code: StatusCode::TEMPORARY_REDIRECT,
      inner: actix_web::web::Redirect::to(to),
    }
  }

  /// Wrapper for [`actix_web::web::Redirect`](https://docs.rs/actix-web/*/actix_web/web/struct.Redirect.html#method.permanent).
  pub fn permanent(self) -> Self {
    Redirect {
      path: self.path,
      redirect: self.redirect,
      code: StatusCode::PERMANENT_REDIRECT,
      inner: self.inner.permanent(),
    }
  }

  /// Wrapper for [`actix_web::web::Redirect`](https://docs.rs/actix-web/*/actix_web/web/struct.Redirect.html#method.temporary).
  pub fn temporary(self) -> Self {
    Redirect {
      path: self.path,
      redirect: self.redirect,
      code: StatusCode::TEMPORARY_REDIRECT,
      inner: self.inner.temporary(),
    }
  }

  /// Wrapper for [`actix_web::web::Redirect`](https://docs.rs/actix-web/*/actix_web/web/struct.Redirect.html#method.see_other).
  pub fn see_other(self) -> Self {
    Redirect {
      path: self.path,
      redirect: self.redirect,
      code: StatusCode::SEE_OTHER,
      inner: self.inner.see_other(),
    }
  }

  /// Wrapper for [`actix_web::web::Redirect`](https://docs.rs/actix-web/*/actix_web/web/struct.Redirect.html#method.using_status_code).
  pub fn using_status_code(mut self, status: StatusCode) -> Self {
    self = Redirect {
      path: self.path,
      redirect: self.redirect,
      code: status,
      inner: self.inner.using_status_code(status),
    };
    self
  }

  pub(crate) fn get_open_api_response(&self) -> Response {
    let location_header = Header {
      definition: Some(ParameterDefinition::Content(BTreeMap::from_iter(vec![(
        "text/plain".to_string(),
        MediaType {
          schema: Some(ReferenceOr::Object(Schema::Object(SchemaObject {
            enum_values: Some(vec![Value::String(self.redirect.clone())]),
            ..Default::default()
          }))),
          ..Default::default()
        },
      )]))),
      description: Some("Redirection URL".to_owned()),
      ..Default::default()
    };

    Response {
      headers: BTreeMap::from_iter(vec![("Location".to_string(), ReferenceOr::Object(location_header))]),
      ..Default::default()
    }
  }
}

impl HttpServiceFactory for Redirect {
  fn register(self, config: &mut AppService) {
    self.inner.register(config);
  }
}

impl Responder for Redirect {
  type Body = ();

  fn respond_to(self, req: &HttpRequest) -> HttpResponse<Self::Body> {
    self.inner.respond_to(req)
  }
}

pub fn redirect(from: impl Into<Cow<'static, str>>, to: impl Into<Cow<'static, str>>) -> Redirect {
  Redirect::new(from, to)
}