Organization ownership (#796)

* organization changes

* changes

* fixes failing test

* version changes

* removed printlns

* add_team_member comes pre-accepted

* no notification on force accept

* fixes tests

* merge fixes

src/database/models/ids.rs

@@ -219,9 +219,6 @@ pub struct ProjectTypeId(pub i32);
 pub struct StatusId(pub i32);
 #[derive(Copy, Clone, Debug, Type, Serialize, Deserialize)]
 #[sqlx(transparent)]
-pub struct SideTypeId(pub i32);
-#[derive(Copy, Clone, Debug, Type, Serialize, Deserialize)]
-#[sqlx(transparent)]
 pub struct GameId(pub i32);
 #[derive(Copy, Clone, Debug, Type, Serialize, Deserialize, PartialEq, Eq, Hash)]
 #[sqlx(transparent)]

src/database/models/loader_fields.rs

@@ -339,12 +339,6 @@ pub struct QueryLoaderFieldEnumValue {
     pub metadata: Option<serde_json::Value>,
 }
 
-#[derive(Clone, Serialize, Deserialize, Debug)]
-pub struct SideType {
-    pub id: SideTypeId,
-    pub name: String,
-}
-
 impl LoaderField {
     pub async fn get_field<'a, E>(
         field: &str,

src/database/models/organization_item.rs

@@ -256,31 +256,9 @@ impl Organization {
         transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
         redis: &RedisPool,
     ) -> Result<Option<()>, super::DatabaseError> {
-        use futures::TryStreamExt;
-
         let organization = Self::get_id(id, &mut **transaction, redis).await?;
 
         if let Some(organization) = organization {
-            let projects: Vec<ProjectId> = sqlx::query!(
-                "
-                SELECT m.id
-                FROM mods m
-                WHERE m.organization_id = $1
-                ",
-                id as OrganizationId,
-            )
-            .fetch_many(&mut **transaction)
-            .try_filter_map(|e| async { Ok(e.right().map(|m| ProjectId(m.id))) })
-            .try_collect::<Vec<ProjectId>>()
-            .await?;
-
-            for project_id in projects {
-                let _result =
-                    super::project_item::Project::remove(project_id, transaction, redis).await?;
-            }
-
-            Organization::clear_cache(id, Some(organization.name), redis).await?;
-
             sqlx::query!(
                 "
                 DELETE FROM organizations

src/database/models/team_item.rs

@@ -412,10 +412,10 @@ impl TeamMember {
         sqlx::query!(
             "
             INSERT INTO team_members (
-                id, team_id, user_id, role, permissions, organization_permissions, accepted
+                id, team_id, user_id, role, permissions, organization_permissions, is_owner, accepted
             )
             VALUES (
-                $1, $2, $3, $4, $5, $6, $7
+                $1, $2, $3, $4, $5, $6, $7, $8
             )
             ",
             self.id as TeamMemberId,
@@ -424,6 +424,7 @@ impl TeamMember {
             self.role,
             self.permissions.bits() as i64,
             self.organization_permissions.map(|p| p.bits() as i64),
+            self.is_owner,
             self.accepted,
         )
         .execute(&mut **transaction)
@@ -576,20 +577,28 @@ impl TeamMember {
     pub async fn get_from_user_id_project<'a, 'b, E>(
         id: ProjectId,
         user_id: UserId,
+        allow_pending: bool,
         executor: E,
     ) -> Result<Option<Self>, super::DatabaseError>
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let accepted = if allow_pending {
+            vec![true, false]
+        } else {
+            vec![true]
+        };
+
         let result = sqlx::query!(
             "
             SELECT tm.id, tm.team_id, tm.user_id, tm.role, tm.is_owner, tm.permissions, tm.organization_permissions, tm.accepted, tm.payouts_split, tm.ordering
             FROM mods m
-            INNER JOIN team_members tm ON tm.team_id = m.team_id AND user_id = $2 AND accepted = TRUE
+            INNER JOIN team_members tm ON tm.team_id = m.team_id AND user_id = $2 AND accepted = ANY($3)
             WHERE m.id = $1
             ",
             id as ProjectId,
-            user_id as UserId
+            user_id as UserId,
+            &accepted
         )
             .fetch_optional(executor)
             .await?;
@@ -618,20 +627,27 @@ impl TeamMember {
     pub async fn get_from_user_id_organization<'a, 'b, E>(
         id: OrganizationId,
         user_id: UserId,
+        allow_pending: bool,
         executor: E,
     ) -> Result<Option<Self>, super::DatabaseError>
     where
         E: sqlx::Executor<'a, Database = sqlx::Postgres>,
     {
+        let accepted = if allow_pending {
+            vec![true, false]
+        } else {
+            vec![true]
+        };
         let result = sqlx::query!(
             "
             SELECT tm.id, tm.team_id, tm.user_id, tm.role, tm.is_owner, tm.permissions, tm.organization_permissions, tm.accepted, tm.payouts_split, tm.ordering
             FROM organizations o
-            INNER JOIN team_members tm ON tm.team_id = o.team_id AND user_id = $2 AND accepted = TRUE
+            INNER JOIN team_members tm ON tm.team_id = o.team_id AND user_id = $2 AND accepted = ANY($3)
             WHERE o.id = $1
             ",
             id as OrganizationId,
-            user_id as UserId
+            user_id as UserId,
+            &accepted
         )
             .fetch_optional(executor)
             .await?;