init

src/services/server.rs

@@ -1,5 +1,4 @@
-use crate::models::{role, server, server_user};
-use crate::repositories::Repositories;
+use crate::models::{role, role_user, server, server_user};
 use crate::services::ServicesContext;
 use sea_orm::{
     ActiveModelTrait, ColumnTrait, EntityTrait, QueryFilter, QueryOrder, QuerySelect, Set,
@@ -21,7 +20,9 @@ impl ServerService {
     pub async fn create_server(
         &self,
         name: String,
+        password: Option<String>,
         is_default: bool,
+        owner_id: Uuid,
     ) -> Result<server::Model, anyhow::Error> {
         let db = &self.service_context.repositories.server.context.db;
         let event_bus = &self.service_context.event_bus;
@@ -30,7 +31,9 @@ impl ServerService {
 
         let active = server::ActiveModel {
             name: Set(name),
+            password: Set(password),
             is_default: Set(is_default),
+            owner_id: Set(Some(owner_id)),
             ..Default::default()
         };
         let srv = active.insert(&txn).await?;
@@ -41,7 +44,22 @@ impl ServerService {
             is_default: Set(true),
             ..Default::default()
         };
-        default_group.insert(&txn).await?;
+        let default_group = default_group.insert(&txn).await?;
+
+        server_user::ActiveModel {
+            server_id: Set(srv.id),
+            user_id: Set(owner_id),
+            ..Default::default()
+        }
+        .insert(&txn)
+        .await?;
+
+        role_user::ActiveModel {
+            role_id: Set(default_group.id),
+            user_id: Set(owner_id),
+        }
+        .insert(&txn)
+        .await?;
 
         txn.commit().await?;
 
@@ -50,6 +68,66 @@ impl ServerService {
         Ok(srv)
     }
 
+    pub async fn join_server(
+        &self,
+        server_id: Uuid,
+        user_id: Uuid,
+        password: Option<String>,
+    ) -> Result<server::Model, anyhow::Error> {
+        let db = &self.service_context.repositories.server.context.db;
+        let event_bus = &self.service_context.event_bus;
+        let txn = db.begin().await?;
+        let srv = server::Entity::find_by_id(server_id)
+            .one(&txn)
+            .await?
+            .ok_or_else(|| anyhow::anyhow!("Server not found"))?;
+
+        if srv.password != password {
+            return Err(anyhow::anyhow!("Invalid server password"));
+        }
+
+        if server_user::Entity::find()
+            .filter(server_user::Column::ServerId.eq(server_id))
+            .filter(server_user::Column::UserId.eq(user_id))
+            .one(&txn)
+            .await?
+            .is_some()
+        {
+            txn.commit().await?;
+            return Ok(srv);
+        }
+
+        server_user::ActiveModel {
+            server_id: Set(server_id),
+            user_id: Set(user_id),
+            ..Default::default()
+        }
+        .insert(&txn)
+        .await?;
+
+        let default_role = role::Entity::find()
+            .filter(role::Column::ServerId.eq(server_id))
+            .filter(role::Column::IsDefault.eq(true))
+            .one(&txn)
+            .await?
+            .ok_or_else(|| anyhow::anyhow!("Default role not found"))?;
+        role_user::ActiveModel {
+            role_id: Set(default_role.id),
+            user_id: Set(user_id),
+        }
+        .insert(&txn)
+        .await?;
+
+        txn.commit().await?;
+        event_bus.emit("server_user_created", (server_id, user_id));
+        self.service_context
+            .repositories
+            .read_state
+            .mark_server_read(server_id, user_id)
+            .await?;
+        Ok(srv)
+    }
+
     pub async fn update_server(
         &self,
         id: Uuid,