autter-core 2.0.2

use crate::{
    DataManager,
    model::{
        Error, Result, User, UserPermission,
        organizations::{OrganizationMembership, OrganizationRole},
    },
};
use oiseau::{PostgresRow, cache::Cache, execute, get, params, query_row, query_rows};
use tetratto_core2::{auto_method, model::id::Id};

impl DataManager {
    /// Get a [`OrganizationMembership`] from an SQL row.
    pub(crate) fn get_organization_membership_from_row(x: &PostgresRow) -> OrganizationMembership {
        OrganizationMembership {
            id: Id::deserialize(&get!(x->0(String))),
            created: get!(x->1(i64)) as u128,
            organization: Id::deserialize(&get!(x->2(String))),
            owner: Id::Legacy(get!(x->3(i64)) as usize),
            role: serde_json::from_str(&get!(x->4(String))).unwrap(),
        }
    }

    auto_method!(get_organization_membership_by_id()@get_organization_membership_from_row -> "SELECT * FROM a_organization_memberships WHERE id = $1" --name="organization_membership" --returns=OrganizationMembership --cache-key-tmpl="srmp.organization_membership:{}");

    /// Get all organization_memberships by user.
    ///
    /// # Arguments
    /// * `user` - the ID of the user to fetch organization_memberships for
    pub async fn get_organization_memberships_by_user(
        &self,
        user: &Id,
    ) -> Result<Vec<OrganizationMembership>> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_rows!(
            &conn,
            "SELECT * FROM a_organization_memberships WHERE owner = $1 ORDER BY created",
            &[&(user.as_usize() as i64)],
            |x| { Self::get_organization_membership_from_row(x) }
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        Ok(res.unwrap())
    }

    /// Get all organization_memberships by organization (paginated).
    ///
    /// # Arguments
    /// * `organization` - the ID of the user to fetch organization_memberships for
    pub async fn get_organization_memberships_by_organization(
        &self,
        organization: &Id,
        batch: usize,
        page: usize,
    ) -> Result<Vec<OrganizationMembership>> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_rows!(
            &conn,
            "SELECT * FROM a_organization_memberships WHERE organization = $1 ORDER BY created DESC LIMIT $2 OFFSET $3",
            &[
                &organization.printable(),
                &(batch as i64),
                &((page * batch) as i64)
            ],
            |x| { Self::get_organization_membership_from_row(x) }
        );

        if res.is_err() {
            return Err(Error::GeneralNotFound(
                "organization_membership".to_string(),
            ));
        }

        Ok(res.unwrap())
    }

    /// Get an organization membership by user and organization.
    ///
    /// # Arguments
    /// * `user` - the ID of the user to fetch organization_memberships for
    /// * `org` - the ID of the organization
    pub async fn get_organization_membership_by_owner_organization(
        &self,
        user: &Id,
        organization: &Id,
    ) -> Result<OrganizationMembership> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = query_row!(
            &conn,
            "SELECT * FROM a_organization_memberships WHERE owner = $1 AND organization = $2 LIMIT 1",
            &[&(user.as_usize() as i64), &organization.printable()],
            |x| { Ok(Self::get_organization_membership_from_row(x)) }
        );

        if res.is_err() {
            return Err(Error::GeneralNotFound(
                "organization_membership".to_string(),
            ));
        }

        Ok(res.unwrap())
    }

    /// Create a new organization_membership in the database.
    ///
    /// # Arguments
    /// * `data` - a mock [`OrganizationMembership`] object to insert
    pub async fn create_organization_membership(&self, data: OrganizationMembership) -> Result<()> {
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = execute!(
            &conn,
            "INSERT INTO a_organization_memberships VALUES ($1, $2, $3, $4, $5)",
            params![
                &data.id.printable(),
                &(data.created as i64),
                &data.organization.printable(),
                &(data.owner.as_usize() as i64),
                &serde_json::to_string(&data.role).unwrap()
            ]
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        // return
        self.incr_organization_members(&data.organization).await?;
        Ok(())
    }

    pub async fn delete_organization_membership(&self, id: &Id, user: User) -> Result<()> {
        let organization_membership = self.get_organization_membership_by_id(&id).await?;
        let org = self
            .get_organization_by_id(&organization_membership.organization)
            .await?;

        if user.id != organization_membership.owner
            && user.id != org.owner
            && !user
                .permissions
                .contains(&UserPermission::ManageOrganizations)
        {
            return Err(Error::NotAllowed);
        }

        // delete user if they're a tenant user and they're trying to leave the org
        let membership_user = if user.id == organization_membership.owner {
            user
        } else {
            self.get_user_by_id(&organization_membership.owner).await?
        };

        if membership_user.org_as_tenant
            && membership_user.principal_org == organization_membership.organization
        {
            self.delete_user(&membership_user.id, "", true).await?;
        }

        // ...
        let conn = match self.0.connect().await {
            Ok(c) => c,
            Err(e) => return Err(Error::DatabaseConnection(e.to_string())),
        };

        let res = execute!(
            &conn,
            "DELETE FROM a_organization_memberships WHERE id = $1",
            &[&id.printable()]
        );

        if let Err(e) = res {
            return Err(Error::DatabaseError(e.to_string()));
        }

        self.0
            .1
            .remove(format!("srmp.organization_membership:{}", id))
            .await;

        // return
        self.decr_organization_members(&org.id).await?;
        Ok(())
    }

    auto_method!(update_organization_membership_role(OrganizationRole) -> "UPDATE a_organization_memberships SET role = $1 WHERE id = $2" --serde --cache-key-tmpl="srmp.organization_membership:{}");
}