Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

10.8 KB
Raw Blame
//! A form's facts and lifecycle: metadata changes, rename, trash, restore
//! and permanent deletion. Only renaming a form that goes by its database's
//! name touches the database.

use crate::domain::drafts::{FormDraftRepository, FormDraftStore};

use std::collections::HashMap;

use databases::domain::models::Viewer;
use databases::domain::ports::{DatabaseMetadataReads, DatabaseRowReads, DatabasesService};
use entity_access::domain::models::{
    AccessLevel, EditAccessLevel, EntityAccessReceipt, OwnerAccessLevel,
};
use macro_event_broker::MacroEventBroker;
use macro_user_id::user_id::MacroUserIdStr;
use models_forms::MAX_TEXT_LENGTH;
use uuid::Uuid;

use super::layout::file_columns;
use super::{
    FormsServiceImpl, access_of, receipt_access, receipt_attribution, receipt_form_id,
    repository_error, validated_name, within,
};
use crate::domain::events::{
    FormChangedMetadata, FormPurgedMetadata, FormRenamedMetadata, FormTopicEvent,
};
use crate::domain::models::{
    Audience, ForbiddenWidget, Form, FormAccess, FormError, FormId, FormUpdate, ListedForm,
    SharingRefusal, UpdateForm, Widget,
};
use crate::domain::ports::{
    Clock, FormAccessDirectory, FormEventPublisher, FormImageFiles, FormsRepo,
};

impl<Repository, Databases, Access, Events, Now, Broker, Drafts, Images>
    FormsServiceImpl<Repository, Databases, Access, Events, Now, Broker, Drafts, Images>
where
    Repository: FormsRepo + FormDraftRepository,
    Databases: DatabasesService + DatabaseRowReads + DatabaseMetadataReads,
    Access: FormAccessDirectory,
    Events: FormEventPublisher,
    Now: Clock,
    Broker: MacroEventBroker,
    Drafts: FormDraftStore,
    Images: FormImageFiles,
{
    /// The live forms the viewer holds a grant on, newest first, each with
    /// the viewer's level as the grants answer it.
    pub(super) async fn catalog(&self, viewer: &Viewer) -> Result<Vec<ListedForm>, FormError> {
        let grants: HashMap<FormId, AccessLevel> = self
            .access
            .accessible_forms(&viewer.user_id)
            .await
            .map_err(|error| {
                FormError::AccessDirectory(rootcause::Report::new(error).into_dynamic())
            })?
            .into_iter()
            .collect();
        let ids: Vec<FormId> = grants.keys().copied().collect();
        let forms = self
            .repository
            .forms_by_ids(&ids)
            .await
            .map_err(repository_error)?;
        let mut forms = self.named_forms(forms).await?;
        forms.sort_by(|left, right| right.created_at.cmp(&left.created_at));
        Ok(forms
            .into_iter()
            .filter_map(|form| {
                let access = access_of(*grants.get(&form.id)?);
                Some(ListedForm { form, access })
            })
            .collect())
    }

    pub(super) async fn change_facts(
        &self,
        receipt: &EntityAccessReceipt<EditAccessLevel>,
        update: UpdateForm,
    ) -> Result<Form, FormError> {
        let stored = self.live_stored_form(receipt_form_id(receipt)?).await?;
        let form = stored.form;
        if update.needs_owner() && receipt_access(receipt) < FormAccess::Owner {
            return Err(FormError::OwnerOnly);
        }
        for text in [&update.description, &update.confirmation_message]
            .into_iter()
            .flatten()
        {
            within(text, MAX_TEXT_LENGTH)?;
        }
        let actor = receipt.acting_user_id();
        for (chosen, current) in [
            (update.logo_file_id, form.branding.logo_file_id),
            (update.cover_file_id, form.branding.cover_file_id),
        ] {
            if let Some(Some(file)) = chosen
                && Some(file) != current
            {
                self.check_branding_image(file, actor).await?;
            }
        }
        // A public form asks for no file: going public holds only if no
        // question asks for one when the change commits. A file widget left
        // on a column the grid retyped asks for nothing, so only the
        // table's current link columns count; a form whose table is gone
        // asks for nothing at all.
        let forbidden_widget = match update.audience {
            Some(Audience::Public) => Some(ForbiddenWidget {
                widget: Widget::File,
                columns: self
                    .table_of(&form)
                    .await?
                    .as_ref()
                    .map(file_columns)
                    .unwrap_or_default(),
            }),
            Some(Audience::Members) | None => None,
        };
        match self
            .repository
            .update_form(form.id, &update, self.now(), forbidden_widget)
            .await
            .map_err(repository_error)?
        {
            FormUpdate::Updated(form) => {
                self.announce(form.id).await;
                self.named(*form, stored.name_follows_database).await
            }
            FormUpdate::FormGone => Err(FormError::NotFound),
            FormUpdate::WidgetInUse => Err(FormError::FileUploadNeedsSignIn),
            FormUpdate::AnonymityLocked => Err(SharingRefusal::AnonymityLocked.into()),
        }
    }

    /// A logo or cover must be an image the caller uploaded, so a form never
    /// shows a file someone else chose to keep to themselves. Keeping the
    /// image a form already shows needs no check. Whether its bytes landed is
    /// not asked: storage marks that only after the upload is used here.
    async fn check_branding_image(
        &self,
        file: Uuid,
        actor: Option<&MacroUserIdStr<'static>>,
    ) -> Result<(), FormError> {
        let stored = self
            .images
            .image_file(file)
            .await
            .map_err(repository_error)?
            .ok_or(FormError::InvalidBranding("the image is not available"))?;
        if actor.is_none_or(|actor| stored.owner_id != actor.as_ref()) {
            return Err(FormError::InvalidBranding(
                "the image must be one you uploaded",
            ));
        }
        if !matches!(
            stored.content_type.as_str(),
            "image/jpeg" | "image/png" | "image/webp" | "image/gif"
        ) {
            return Err(FormError::InvalidBranding(
                "the image must be a JPEG, PNG, WebP or GIF",
            ));
        }
        Ok(())
    }

    /// Rename a form: the database it goes by, when it follows one, then a
    /// stamp of the form itself; otherwise the form's own name.
    pub(super) async fn rename(
        &self,
        receipt: &EntityAccessReceipt<EditAccessLevel>,
        name: &str,
    ) -> Result<Form, FormError> {
        let stored = self.live_stored_form(receipt_form_id(receipt)?).await?;
        let form = stored.form;
        let name = validated_name(name)?;
        let renamed = if stored.name_follows_database {
            let name = self.rename_database_of(receipt, &form, name).await?;
            let touched = self
                .repository
                .touch_form(form.id, self.now())
                .await
                .map_err(repository_error)?
                .ok_or(FormError::NotFound)?;
            Form { name, ..touched }
        } else {
            self.repository
                .rename_form(form.id, &name, self.now())
                .await
                .map_err(repository_error)?
                .ok_or(FormError::NotFound)?
        };
        let name = renamed.name.clone();
        self.announce(form.id).await;
        self.emit(FormTopicEvent::Renamed(FormRenamedMetadata {
            form_id: form.id,
            attribution: receipt_attribution(receipt),
            name,
        }));
        Ok(renamed)
    }

    pub(super) async fn trash(
        &self,
        receipt: &EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<(), FormError> {
        let stored = self.stored_form(receipt_form_id(receipt)?).await?;
        if stored.trashed_at.is_some() {
            return Ok(());
        }
        if !self
            .repository
            .trash_form(stored.form.id, self.now())
            .await
            .map_err(repository_error)?
        {
            return Err(FormError::NotFound);
        }
        self.announce(stored.form.id).await;
        self.emit(FormTopicEvent::Trashed(FormChangedMetadata {
            form_id: stored.form.id,
            attribution: receipt_attribution(receipt),
        }));
        Ok(())
    }

    /// File a live form in a folder, or at the root, answering the folder
    /// it left. Its database stays where it is.
    #[cfg(feature = "entity_mutation")]
    pub(crate) async fn move_to_folder(
        &self,
        receipt: &EntityAccessReceipt<OwnerAccessLevel>,
        project_id: Option<&str>,
    ) -> Result<Option<String>, FormError> {
        let stored = self.stored_form(receipt_form_id(receipt)?).await?;
        if stored.trashed_at.is_some()
            || !self
                .repository
                .move_form(stored.form.id, project_id)
                .await
                .map_err(repository_error)?
        {
            return Err(FormError::NotFound);
        }
        self.announce(stored.form.id).await;
        Ok(stored.form.project_id)
    }

    pub(super) async fn restore(
        &self,
        receipt: &EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<(), FormError> {
        let stored = self.stored_form(receipt_form_id(receipt)?).await?;
        if stored.trashed_at.is_none() {
            return Ok(());
        }
        if !self
            .repository
            .restore_form(stored.form.id)
            .await
            .map_err(repository_error)?
        {
            return Err(FormError::NotFound);
        }
        self.announce(stored.form.id).await;
        self.emit(FormTopicEvent::Restored(FormChangedMetadata {
            form_id: stored.form.id,
            attribution: receipt_attribution(receipt),
        }));
        Ok(())
    }

    pub(super) async fn purge(
        &self,
        receipt: &EntityAccessReceipt<OwnerAccessLevel>,
    ) -> Result<(), FormError> {
        let stored = self.stored_form(receipt_form_id(receipt)?).await?;
        // The row goes first: a form whose delete failed stays restorable
        // with its surface, and a retired surface never comes back.
        self.repository
            .delete_form(stored.form.id)
            .await
            .map_err(repository_error)?;
        // The purge stands either way. Collab surfaces retire a form's
        // surface whose form is gone the next time it is asked for, as they
        // do when a database, table or owner purge cascades to the form.
        if let Err(error) = self.drafts.retire(stored.form.id).await {
            tracing::error!(form_id = %stored.form.id, error = ?error, "failed to retire a purged form's surface");
        }
        self.announce(stored.form.id).await;
        self.emit(FormTopicEvent::Purged(FormPurgedMetadata {
            form_id: stored.form.id,
        }));
        Ok(())
    }
}