    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

    /*
    * Copyright (C) 2022  Aravinth Manivannan <realaravinth@batsense.net>
    *
    * This program is free software: you can redistribute it and/or modify
    * it under the terms of the GNU Affero General Public License as
    * published by the Free Software Foundation, either version 3 of the
    * License, or (at your option) any later version.
    *
    * This program is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
    * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    * GNU Affero General Public License for more details.
    *
    * You should have received a copy of the GNU Affero General Public License
    * along with this program.  If not, see <https://www.gnu.org/licenses/>.
    */
    //! V1 API Routes
    use actix_auth_middleware::GetLoginRoute;

    use crate::serve::routes::Serve;

    use super::meta::routes::Meta;
    use super::pages::routes::Deploy;

    /// constant [Routes](Routes) instance
    pub const ROUTES: Routes = Routes::new();

    /// Authentication routes
    pub struct Auth {
        /// logout route
        pub logout: &'static str,
        /// login route
        pub login: &'static str,
        /// registration route
        pub register: &'static str,
    }
    impl Auth {
        /// create new instance of Authentication route
        pub const fn new() -> Auth {
            let login = "/api/v1/signin";
            let logout = "/api/v1/logout";
            let register = "/api/v1/signup";
            Auth {
                logout,
                login,
                register,
            }
        }
    }

    /// Account management routes
    pub struct Account {
        /// delete account route
        pub delete: &'static str,
        /// route to check if an email exists
        pub email_exists: &'static str,
        /// route to update a user's email
        pub update_email: &'static str,
        ///    route to update password
        pub update_password: &'static str,
        ///    route to check if a username is already registered
        pub username_exists: &'static str,
        ///    route to change username
        pub update_username: &'static str,
    }

    impl Account {
        /// create a new instance of [Account][Account] routes
        pub const fn new() -> Account {
            let delete = "/api/v1/account/delete";
            let email_exists = "/api/v1/account/email/exists";
            let username_exists = "/api/v1/account/username/exists";
            let update_username = "/api/v1/account/username/update";
            let update_email = "/api/v1/account/email/update";
            let update_password = "/api/v1/account/password/update";
            Account {
                delete,
                email_exists,
                update_email,
                update_password,
                username_exists,
                update_username,
            }
        }
    }

    /// Top-level routes data structure for V1 AP1
    pub struct Routes {
        /// Authentication routes
        pub auth: Auth,
        /// Account routes
        pub account: Account,
        /// Meta routes
        pub meta: Meta,
        pub deploy: Deploy,
        pub serve: Serve,
    }

    impl Routes {
        /// create new instance of Routes
        const fn new() -> Routes {
            Routes {
                auth: Auth::new(),
                account: Account::new(),
                meta: Meta::new(),
                deploy: Deploy::new(),
                serve: Serve::new(),
            }
        }
    }

    impl GetLoginRoute for Routes {
        fn get_login_route(&self, src: Option<&str>) -> String {
            if let Some(redirect_to) = src {
                format!(
                    "{}?redirect_to={}",
                    self.auth.login,
                    urlencoding::encode(redirect_to)
                )
            } else {
                self.auth.register.to_string()
            }
        }
    }