backend signup

backend/src/tenants.rs

@@ -55,15 +55,46 @@ impl TenantService {
         initial_members: &[Uuid],
         created_by: Option<Uuid>,
     ) -> AppResult<Tenant> {
-        let name = name.trim();
-        if name.is_empty() {
-            return Err(AppError::bad_request("tenant name must not be empty"));
-        }
-
         let mut conn = self.pool.get().map_err(|err| {
             tracing::error!(error = ?err, "database pool error");
             AppError::internal("database pool error")
         })?;
+        self.create_tenant_with_conn(
+            &mut conn,
+            name,
+            storage_root,
+            quickwit_index,
+            status,
+            initial_members,
+            created_by,
+        )
+    }
+
+    fn load<F>(&self, loader: F) -> AppResult<Tenant>
+    where
+        F: FnOnce(&mut PgConnection) -> AppResult<Tenant>,
+    {
+        let mut conn = self.pool.get().map_err(|err| {
+            tracing::error!(error = ?err, "database pool error");
+            AppError::internal("database pool error")
+        })?;
+        let tenant = loader(&mut conn)?;
+        Ok(tenant)
+    }
+    pub fn create_tenant_with_conn(
+        &self,
+        conn: &mut PgConnection,
+        name: &str,
+        storage_root: Option<&str>,
+        quickwit_index: Option<&str>,
+        status: TenantStatus,
+        initial_members: &[Uuid],
+        created_by: Option<Uuid>,
+    ) -> AppResult<Tenant> {
+        let name = name.trim();
+        if name.is_empty() {
+            return Err(AppError::bad_request("tenant name must not be empty"));
+        }
 
         let id = Uuid::new_v4();
         let storage_root = normalize_storage_root(storage_root, id);
@@ -79,32 +110,20 @@ impl TenantService {
                 dsl::status.eq(status),
                 dsl::created_by.eq(created_by),
             ))
-            .execute(&mut conn)?;
+            .execute(conn)?;
 
         if status == TenantStatus::Creating {
             let payload = json!({
                 "members": initial_members,
             });
 
-            enqueue_job(&mut conn, id, JOB_PROVISION_TENANT, payload, None).map_err(|err| {
+            enqueue_job(conn, id, JOB_PROVISION_TENANT, payload, None).map_err(|err| {
                 tracing::error!(error = ?err, tenant_id = %id, "failed to enqueue tenant provisioning job");
                 AppError::internal("failed to enqueue tenant provisioning job")
             })?;
         }
 
-        TenantRepository::get_by_id(&mut conn, id)
-    }
-
-    fn load<F>(&self, loader: F) -> AppResult<Tenant>
-    where
-        F: FnOnce(&mut PgConnection) -> AppResult<Tenant>,
-    {
-        let mut conn = self.pool.get().map_err(|err| {
-            tracing::error!(error = ?err, "database pool error");
-            AppError::internal("database pool error")
-        })?;
-        let tenant = loader(&mut conn)?;
-        Ok(tenant)
+        TenantRepository::get_by_id(conn, id)
     }
 }