made progress on user

harsh-common/src/client.rs

@@ -53,6 +53,42 @@ pub struct MessageSetContent {
     pub content: String,
 }
 
+#[derive(Debug)]
+pub struct UserList {}
+
+#[derive(Debug)]
+pub struct UserCreate {
+    pub name: String,
+    pub pass: String,
+}
+
+#[derive(Debug)]
+pub struct UserDelete {
+    pub id: u64,
+}
+
+#[derive(Debug)]
+pub struct UserGetName {
+    pub id: u64,
+}
+
+#[derive(Debug)]
+pub struct UserSetName {
+    pub id: u64,
+    pub name: String,
+}
+
+#[derive(Debug)]
+pub struct UserGetPass {
+    pub id: u64,
+}
+
+#[derive(Debug)]
+pub struct UserSetPass {
+    pub id: u64,
+    pub pass: String,
+}
+
 #[derive(Debug)]
 pub enum ClientRequest {
     Ping(Ping),
@@ -61,11 +97,19 @@ pub enum ClientRequest {
     ChannelDelete(ChannelDelete),
     ChannelGetName(ChannelGetName),
     ChannelSetName(ChannelSetName),
+
     MessageList(MessageList),
     MessageCreate(MessageCreate),
     MessageDelete(MessageDelete),
     MessageGetContent(MessageGetContent),
     MessageSetContent(MessageSetContent),
+
+    UserList(UserList),
+    UserCreate(UserCreate),
+    UserDelete(UserDelete),
+    UserGetName(UserGetName),
+    UserSetName(UserSetName),
+    UserSetPass(UserSetPass),
 }
 
 impl ClientRequest {
@@ -162,6 +206,12 @@ impl ClientRequest {
                 id,
                 channel_id,
             }),
+            user_list {} => Self::UserList(UserList {}),
+            user_create { name, pass } => Self::UserCreate(UserCreate { name, pass }),
+            user_delete { id } => Self::UserDelete(UserDelete { id }),
+            user_get_name { id } => Self::UserGetName(UserGetName { id }),
+            user_set_name { id, name } => Self::UserSetName(UserSetName { id, name }),
+            user_set_pass { id, pass } => Self::UserSetPass(UserSetPass { id, pass }),
         };
         Some(mapped)
     }
@@ -208,6 +258,12 @@ impl ClientRequest {
                 channel_id,
                 content,
             },
+            Self::UserList(UserList {}) => user_list {},
+            Self::UserCreate(UserCreate { name, pass }) => user_create { name, pass },
+            Self::UserDelete(UserDelete { id }) => user_delete { id },
+            Self::UserGetName(UserGetName { id }) => user_get_name { id },
+            Self::UserSetName(UserSetName { id, name }) => user_set_name { id, name },
+            Self::UserSetPass(UserSetPass { id, pass }) => user_set_pass { id, pass },
         };
         serde_json::to_string(&mapped).unwrap()
     }
@@ -258,5 +314,24 @@ mod repr {
             id: u64,
             content: String,
         },
+        user_list {},
+        user_create {
+            name: String,
+            pass: String,
+        },
+        user_delete {
+            id: u64,
+        },
+        user_get_name {
+            id: u64,
+        },
+        user_set_name {
+            id: u64,
+            name: String,
+        },
+        user_set_pass {
+            id: u64,
+            pass: String,
+        },
     }
 }

harsh-common/src/server.rs

@@ -60,19 +60,59 @@ pub struct MessageSetContent {
     pub content: String,
 }
 
+#[derive(Debug)]
+pub struct UserList {}
+
+#[derive(Debug)]
+pub struct UserCreate {
+    pub id: u64,
+    pub name: String,
+}
+
+#[derive(Debug)]
+pub struct UserDelete {
+    pub id: u64,
+}
+
+#[derive(Debug)]
+pub struct UserGetName {
+    pub id: u64,
+    pub name: Option<String>,
+}
+
+#[derive(Debug)]
+pub struct UserSetName {
+    pub id: u64,
+    pub name: String,
+}
+
+#[derive(Debug)]
+pub struct UserSetPass {
+    pub id: u64,
+}
+
 #[derive(Debug)]
 pub enum ServerRequest {
     Pong(Pong),
+
     ChannelCreate(ChannelCreate),
     ChannelDelete(ChannelDelete),
     ChannelList(ChannelList),
     ChannelGetName(ChannelGetName),
     ChannelSetName(ChannelSetName),
+
     MessageList(MessageList),
     MessageCreate(MessageCreate),
     MessageDelete(MessageDelete),
     MessageGetContent(MessageGetContent),
     MessageSetContent(MessageSetContent),
+
+    UserList(UserList),
+    UserCreate(UserCreate),
+    UserDelete(UserDelete),
+    UserGetName(UserGetName),
+    UserSetName(UserSetName),
+    UserSetPass(UserSetPass),
 }
 
 impl ServerRequest {
@@ -181,6 +221,12 @@ impl ServerRequest {
                 content,
                 id,
             }),
+            user_list {} => Self::UserList(UserList {}),
+            user_create { id, name } => Self::UserCreate(UserCreate { id, name }),
+            user_delete { id } => Self::UserDelete(UserDelete { id }),
+            user_get_name { id, name } => Self::UserGetName(UserGetName { id, name }),
+            user_set_name { id, name } => Self::UserSetName(UserSetName { id, name }),
+            user_set_pass { id } => Self::UserSetPass(UserSetPass { id }),
         };
         Some(mapped)
     }
@@ -232,7 +278,14 @@ impl ServerRequest {
                 id,
                 content,
             },
+            Self::UserList(UserList {}) => user_list {},
+            Self::UserCreate(UserCreate { id, name }) => user_create { id, name },
+            Self::UserDelete(UserDelete { id }) => user_delete { id },
+            Self::UserGetName(UserGetName { id, name }) => user_get_name { id, name },
+            Self::UserSetName(UserSetName { id, name }) => user_set_name { id, name },
+            Self::UserSetPass(UserSetPass { id }) => user_set_pass { id },
         };
+
         serde_json::to_string(&mapped).unwrap()
     }
 }
@@ -289,5 +342,24 @@ mod repr {
             id: u64,
             content: String,
         },
+        user_list {},
+        user_create {
+            id: u64,
+            name: String,
+        },
+        user_delete {
+            id: u64,
+        },
+        user_get_name {
+            id: u64,
+            name: Option<String>,
+        },
+        user_set_name {
+            id: u64,
+            name: String,
+        },
+        user_set_pass {
+            id: u64,
+        },
     }
 }

harsh-server/src/gateway.rs

@@ -16,56 +16,58 @@ pub struct GatewayProc {
 
 impl GatewayProc {
     async fn handle_request(&mut self, address: Addr, request: ClientRequest) {
+        use client as c;
+        use ClientRequest::*;
         match request {
-            ClientRequest::Ping(client::Ping { content }) => {
+            Ping(c::Ping { content }) => self.on_ping(content, address),
-                self.on_ping(content, address);
-            }
 
-            ClientRequest::ChannelCreate(client::ChannelCreate { name }) => {
+            ChannelCreate(c::ChannelCreate { name }) => self.on_channel_create(name).await,
-                self.on_channel_create(name).await;
+            ChannelDelete(c::ChannelDelete { id }) => self.on_channel_delete(id),
-            }
+            ChannelList(c::ChannelList {}) => self.on_channel_list(address).await,
+            ChannelGetName(c::ChannelGetName { id }) => self.on_channel_get_name(id, address).await,
+            ChannelSetName(c::ChannelSetName { id, name }) => self.on_channel_set_name(id, name),
 
-            ClientRequest::ChannelDelete(client::ChannelDelete { id }) => {
+            MessageList(c::MessageList { channel_id }) => {
-                self.on_channel_delete(id);
+                self.on_message_list(channel_id, address).await
             }
-
+            MessageCreate(c::MessageCreate {
-            ClientRequest::ChannelList(client::ChannelList {}) => {
-                self.on_channel_list(address).await;
-            }
-
-            ClientRequest::ChannelGetName(client::ChannelGetName { id }) => {
-                self.on_channel_get_name(id, address).await;
-            }
-
-            ClientRequest::ChannelSetName(client::ChannelSetName { id, name }) => {
-                self.on_channel_set_name(id, name);
-            }
-
-            ClientRequest::MessageList(client::MessageList { channel_id }) => {
-                self.on_message_list(channel_id, address).await;
-            }
-            ClientRequest::MessageCreate(client::MessageCreate {
                 channel_id,
                 content,
-            }) => {
+            }) => self.on_message_create(channel_id, content).await,
-                self.on_message_create(channel_id, content).await;
+            MessageDelete(c::MessageDelete { channel_id, id }) => {
+                self.on_message_delete(channel_id, id)
+            }
+            MessageGetContent(c::MessageGetContent { channel_id, id }) => {
+                self.on_message_get_content(channel_id, id, address).await
             }
 
-            ClientRequest::MessageDelete(client::MessageDelete { id, channel_id }) => {
+            MessageSetContent(c::MessageSetContent {
-                self.on_message_delete(channel_id, id);
+                channel_id,
-            }
-
-            ClientRequest::MessageGetContent(client::MessageGetContent { id, channel_id }) => {
-                self.on_message_get_content(channel_id, id, address).await;
-            }
-
-            ClientRequest::MessageSetContent(client::MessageSetContent {
-                content,
                 id,
-                channel_id,
+                content,
             }) => {
                 self.on_message_set_content(channel_id, id, content);
             }
+
+            // TODO: user
+            UserList(c::UserList {}) => {
+                todo!()
+            }
+            UserCreate(c::UserCreate { name, pass }) => {
+                todo!()
+            }
+            UserDelete(c::UserDelete { id }) => {
+                todo!()
+            }
+            UserGetName(c::UserGetName { id }) => {
+                todo!()
+            }
+            UserSetName(c::UserSetName { id, name }) => {
+                todo!()
+            }
+            UserSetPass(c::UserSetPass { id, pass }) => {
+                todo!()
+            }
         }
     }
 

harsh-server/src/storage.rs

@@ -16,6 +16,13 @@ pub enum StorageCmd {
     MessageDelete(Id, Id),
     MessageGetContent(Id, Id, Sender<Option<String>>),
     MessageSetContent(Id, Id, String),
+    UserList(Sender<Vec<Id>>),
+    UserCreate(String, String, Sender<Id>),
+    UserDelete(Id),
+    UserGetName(Id, Sender<Option<String>>),
+    UserSetName(Id, String),
+    UserGetPass(Id, Sender<Option<String>>),
+    UserSetPass(Id, String),
 }
 
 impl StorageCmd {
@@ -121,37 +128,77 @@ impl StorageProc {
     }
 
     async fn handle_command(&mut self, command: StorageCmd) {
+        use StorageCmd::*;
         match command {
-            StorageCmd::ChannelList(sender) => {
+            //
-                self.on_channel_list(sender);
+            // Channel
-            }
+            //
-            StorageCmd::ChannelCreate(name, sender) => {
+            ChannelList(sender) => self.on_channel_list(sender),
-                self.on_channel_create(name, sender);
+            ChannelCreate(name, sender) => self.on_channel_create(name, sender),
-            }
+            ChannelDelete(id) => self.on_channel_remove(id),
-            StorageCmd::ChannelDelete(id) => self.on_channel_remove(id),
+            ChannelGetName(id, sender) => self.on_channel_get_name(id, sender),
-            StorageCmd::ChannelGetName(id, sender) => {
+            ChannelSetName(id, name) => self.on_channel_set_name(id, name),
-                self.on_channel_get_name(id, sender);
-            }
-            StorageCmd::ChannelSetName(id, name) => {
-                self.on_channel_set_name(id, name);
-            }
             // ChannelGetParent / Set
 
             //
-            StorageCmd::MessageList(channel_id, sender) => {
+            // User
-                self.on_message_list(channel_id, sender);
+            //
+            MessageList(channel_id, sender) => self.on_message_list(channel_id, sender),
+            MessageCreate(channel_id, content, sender) => {
+                self.on_message_create(channel_id, content, sender)
             }
-            StorageCmd::MessageCreate(channel_id, content, sender) => {
+            MessageDelete(channel_id, id) => self.on_message_delete(channel_id, id),
-                self.on_message_create(channel_id, content, sender);
+            MessageGetContent(channel_id, id, sender) => {
+                self.on_message_get_content(channel_id, id, sender)
             }
-            StorageCmd::MessageDelete(channel_id, id) => {
+            MessageSetContent(channel_id, id, content) => {
-                self.on_message_delete(channel_id, id);
+                self.on_message_set_content(channel_id, id, content)
             }
-            StorageCmd::MessageGetContent(channel_id, id, sender) => {
+
-                self.on_message_get_content(channel_id, id, sender);
+            //
+            // User
+            //
+            UserList(sender) => {
+                let users = self.list("/users/");
+                sender.send(users).unwrap();
             }
-            StorageCmd::MessageSetContent(channel_id, id, content) => {
+
-                self.on_message_set_content(channel_id, id, content);
+            UserCreate(name, pass, sender) => {
+                let user = User::new(name, pass);
+                let id = user.get_id();
+                sender.send(id).unwrap();
+            }
+
+            UserDelete(id) => {
+                self.remove(format!("/users/{id}"));
+            }
+
+            UserGetName(id, sender) => {
+                let user = self.get::<_, User>(format!("/users/{id}"));
+                let name = user.map(|u| u.get_name().to_string());
+                sender.send(name).unwrap();
+            }
+
+            UserSetName(id, name) => {
+                let path = format!("/users/{id}");
+                if let Some(mut user) = self.get::<_, User>(&path) {
+                    user.set_name(name);
+                    self.set(path, user);
+                }
+            }
+
+            UserGetPass(id, sender) => {
+                let user = self.get::<_, User>(format!("/users/{id}"));
+                let name = user.map(|u| u.get_pass().to_string());
+                sender.send(name).unwrap();
+            }
+
+            UserSetPass(id, pass) => {
+                let path = format!("/users/{id}");
+                if let Some(mut user) = self.get::<_, User>(&path) {
+                    user.set_pass(pass);
+                    self.set(path, user);
+                }
             }
         };
     }
@@ -192,7 +239,6 @@ impl StorageProc {
     //
     // Messages
     //
-
     fn on_message_list(&mut self, channel_id: Id, sender: Sender<Vec<Id>>) {
         let items = self.list(format!("/messages/{channel_id}/"));
         sender.send(items).unwrap();

harsh-server/src/storage/models.rs

@@ -32,6 +32,34 @@ impl Channel {
 pub struct User {
     id: Id,
     name: String,
+    pass: String,
+}
+
+impl User {
+    pub fn new(name: String, pass: String) -> Self {
+        let id = Id::from_now();
+        Self { id, name, pass }
+    }
+
+    pub fn get_id(&self) -> Id {
+        self.id
+    }
+
+    pub fn get_name(&self) -> &str {
+        &self.name
+    }
+
+    pub fn set_name(&mut self, name: String) {
+        self.name = name
+    }
+
+    pub fn get_pass(&self) -> &str {
+        &self.pass
+    }
+
+    pub fn set_pass(&mut self, pass: String) {
+        self.pass = pass
+    }
 }
 
 #[derive(Debug, Serialize, Deserialize)]