feat!: add telegram auth and async refactor

- Removed "/schedule/update-download-url" endpoint, this mechanism was replaced by Yandex Cloud FaaS. Ура :)
- Improved schedule caching mechanism.
- Added Telegram WebApp authentication support.
- Reworked endpoints responses and errors mechanism.
- Refactored application state management.
- Make synchronous database operations, middlewares and extractors to asynchronous.
- Made user password field optional to support multiple auth methods.
- Renamed users table column "version" to "android_version" and made it nullable.

src/extractors/authorized_user.rs

@@ -1,9 +1,9 @@
-use crate::app_state::AppState;
 use crate::database::driver;
 use crate::database::models::{FCM, User};
-use crate::extractors::base::{FromRequestSync, SyncExtractor};
+use crate::extractors::base::{AsyncExtractor, FromRequestAsync};
+use crate::state::AppState;
 use crate::utility::jwt;
-use actix_macros::ResponseErrorMessage;
+use actix_macros::MiddlewareError;
 use actix_web::body::BoxBody;
 use actix_web::dev::Payload;
 use actix_web::http::header;
@@ -12,13 +12,13 @@ use derive_more::Display;
 use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
 
-#[derive(Clone, Debug, Serialize, Deserialize, Display, ResponseErrorMessage)]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Display, MiddlewareError)]
 #[status_code = "actix_web::http::StatusCode::UNAUTHORIZED"]
 #[serde(rename_all = "SCREAMING_SNAKE_CASE")]
 pub enum Error {
-    /// There is no Authorization header in the request.
-    #[display("No Authorization header found")]
-    NoHeader,
+    /// There is no Authorization header or cookie in the request.
+    #[display("No Authorization header or cookie found")]
+    NoHeaderOrCookieFound,
 
     /// Unknown authorization type other than Bearer.
     #[display("Bearer token is required")]
@@ -39,31 +39,60 @@ impl Error {
     }
 }
 
+fn get_access_token_from_header(req: &HttpRequest) -> Result<String, Error> {
+    let header_value = req
+        .headers()
+        .get(header::AUTHORIZATION)
+        .ok_or(Error::NoHeaderOrCookieFound)?
+        .to_str()
+        .map_err(|_| Error::NoHeaderOrCookieFound)?
+        .to_string();
+
+    let parts = header_value
+        .split_once(' ')
+        .ok_or(Error::UnknownAuthorizationType)?;
+
+    if parts.0 != "Bearer" {
+        Err(Error::UnknownAuthorizationType)
+    } else {
+        Ok(parts.1.to_string())
+    }
+}
+
+fn get_access_token_from_cookies(req: &HttpRequest) -> Result<String, Error> {
+    let cookie = req
+        .cookie("access_token")
+        .ok_or(Error::NoHeaderOrCookieFound)?;
+
+    Ok(cookie.value().to_string())
+}
+
 /// User extractor from request with Bearer access token.
-impl FromRequestSync for User {
+impl FromRequestAsync for User {
     type Error = actix_web::Error;
 
-    fn from_request_sync(req: &HttpRequest, _: &mut Payload) -> Result<Self, Self::Error> {
-        let authorization = req
-            .headers()
-            .get(header::AUTHORIZATION)
-            .ok_or(Error::NoHeader.into_err())?
-            .to_str()
-            .map_err(|_| Error::NoHeader.into_err())?
-            .to_string();
+    async fn from_request_async(
+        req: &HttpRequest,
+        _payload: &mut Payload,
+    ) -> Result<Self, Self::Error> {
+        let access_token = match get_access_token_from_header(req) {
+            Err(Error::NoHeaderOrCookieFound) => {
+                get_access_token_from_cookies(req).map_err(|error| error.into_err())?
+            }
+            Err(error) => {
+                return Err(error.into_err());
+            }
+            Ok(access_token) => access_token,
+        };
 
-        let parts: Vec<&str> = authorization.split(' ').collect();
-
-        if parts.len() != 2 || parts[0] != "Bearer" {
-            return Err(Error::UnknownAuthorizationType.into_err());
-        }
-
-        let user_id = jwt::verify_and_decode(&parts[1].to_string())
+        let user_id = jwt::verify_and_decode(&access_token)
             .map_err(|_| Error::InvalidAccessToken.into_err())?;
 
         let app_state = req.app_data::<web::Data<AppState>>().unwrap();
 
-        driver::users::get(&app_state, &user_id).map_err(|_| Error::NoUser.into())
+        driver::users::get(app_state, &user_id)
+            .await
+            .map_err(|_| Error::NoUser.into())
     }
 }
 
@@ -88,19 +117,22 @@ impl<const FCM: bool> UserExtractor<{ FCM }> {
 }
 
 /// Extractor of user and additional parameters from request with Bearer token.
-impl<const FCM: bool> FromRequestSync for UserExtractor<{ FCM }> {
+impl<const FCM: bool> FromRequestAsync for UserExtractor<{ FCM }> {
     type Error = actix_web::Error;
 
-    fn from_request_sync(req: &HttpRequest, payload: &mut Payload) -> Result<Self, Self::Error> {
-        let user = SyncExtractor::<User>::from_request(req, payload)
-            .into_inner()?
+    async fn from_request_async(
+        req: &HttpRequest,
+        payload: &mut Payload,
+    ) -> Result<Self, Self::Error> {
+        let user = AsyncExtractor::<User>::from_request(req, payload)
+            .await?
             .into_inner();
 
         let app_state = req.app_data::<web::Data<AppState>>().unwrap();
 
         Ok(Self {
             fcm: if FCM {
-                driver::fcm::from_user(&app_state, &user).ok()
+                driver::fcm::from_user(&app_state, &user).await.ok()
             } else {
                 None
             },