Merge pull request #5 from polyphony-chat/feature/register-login

Update main

src/api/auth/register.rs

@@ -1,7 +1,38 @@
 pub mod register {
-    use crate::instance::Instance;
+    use std::fmt;
+
+    use reqwest::Client;
+    use serde_json::json;
+
+    use crate::{api::schemas::schemas::RegisterSchema, instance::Instance};
 
     impl Instance {
-        pub fn register() {}
+        pub fn register(&mut self, register_schema: &RegisterSchema) {
+            let json_schema = json!(register_schema);
+            let limited_requester = &self.requester;
+            let client = Client::new();
+            let endpoint_url = self.urls.get_api().to_string() + "/auth/register";
+            let request_builder = client.post(endpoint_url).body(json_schema.to_string());
+            // TODO
+        }
     }
+
+    #[derive(Debug, PartialEq, Eq)]
+    pub struct RegisterError {
+        pub message: String,
+    }
+
+    impl RegisterError {
+        fn new(message: String) -> Self {
+            RegisterError { message }
+        }
+    }
+
+    impl fmt::Display for RegisterError {
+        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+            write!(f, "{}", self.message)
+        }
+    }
+
+    impl std::error::Error for RegisterError {}
 }

src/api/policies/instance/instance.rs

@@ -25,9 +25,11 @@ pub mod instance {
 
     impl std::error::Error for InstancePoliciesError {}
     impl Instance {
-        /// Gets the instance policies schema.
+        /**
-        /// # Errors
+        Gets the instance policies schema.
-        /// * [`InstancePoliciesError`] - If the request fails.
+        # Errors
+        [`InstancePoliciesError`] - If the request fails.
+        */
         pub async fn instance_policies_schema(
             &self,
         ) -> Result<InstancePoliciesSchema, InstancePoliciesError> {

src/instance.rs

@@ -18,7 +18,7 @@ pub struct Instance {
     pub instance_info: InstancePoliciesSchema,
     pub requester: LimitedRequester,
     //pub gateway: Gateway,
-    //pub users: HashMap<Token, Username>,
+    pub users: HashMap<Token, Username>,
 }
 
 impl Instance {
@@ -32,6 +32,7 @@ impl Instance {
         urls: URLBundle,
         requester: LimitedRequester,
     ) -> Result<Instance, InstanceError> {
+        let users: HashMap<Token, Username> = HashMap::new();
         let mut instance = Instance {
             urls,
             instance_info: InstancePoliciesSchema::new(
@@ -46,8 +47,7 @@ impl Instance {
                 None,
             ),
             requester,
-            //gateway: (),
+            users,
-            //users: (),
         };
         instance.instance_info = match instance.instance_policies_schema().await {
             Ok(schema) => schema,

src/limit.rs

@@ -100,18 +100,37 @@ impl LimitedRequester {
     }
 
     fn can_send_request(&mut self, limit_type: LimitType) -> bool {
-        let limits = self.limits_rate.get(&limit_type);
+        let limits = &self.limits_rate.clone();
-
+        // Check if all of the limits in this vec have at least one remaining request
-        match limits {
+        let constant_limits: Vec<&LimitType> = [
-            Some(limit) => {
+            &LimitType::Error,
-                if limit.remaining > 0 {
+            &LimitType::Global,
-                    true
+            &LimitType::Ip,
-                } else {
+            &limit_type,
-                    false
+        ]
+        .to_vec();
+        for limit in constant_limits.iter() {
+            match limits.get(&limit) {
+                Some(limit) => {
+                    if limit.remaining == 0 {
+                        return false;
+                    }
+                    // AbsoluteRegister and AuthRegister can cancel each other out.
+                    if limit.bucket == LimitType::AbsoluteRegister
+                        && limits.get(&LimitType::AuthRegister).unwrap().remaining == 0
+                    {
+                        return false;
+                    }
+                    if limit.bucket == LimitType::AuthRegister
+                        && limits.get(&LimitType::AbsoluteRegister).unwrap().remaining == 0
+                    {
+                        return false;
+                    }
                 }
+                None => return false,
             }
-            None => false,
         }
+        return true;
     }
 
     fn update_limits(&mut self, response: &Response, limit_type: LimitType) {