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.

20.5 KB
Raw Blame
//! Responding: a new response, a signed-in respondent's edit, and reading
//! one's own response back. The forms service decides; the databases
//! service writes the row under the form's internal receipt.

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

use std::collections::HashMap;

use chrono::{DateTime, DurationRound, TimeDelta, Utc};
use databases::domain::models::{DatabaseError, OpBatch, TableDetail, Viewer};
use databases::domain::ports::{DatabaseMetadataReads, DatabaseRowReads, DatabasesService};
use entity_access::domain::models::{EditAccessLevel, EntityAccessReceipt, ViewAccessLevel};
use macro_event_broker::MacroEventBroker;
use macro_user_id::user_id::MacroUserIdStr;
use models_databases::{
    CellValue, CellWrite, DatabaseOp, EntityKind, EntityRef, OpResult, RowChange, RowChanges,
    RowsChange, RowsResult,
};
use models_forms::UnlockedBooking;

use super::answers::{AnsweredQuestion, Evaluation, evaluate};
use super::layout::{QuestionColumn, gates_fit_table, question_columns};
use super::managed::{respondent_kind, submitted_kind, writable};
use super::{
    FormsServiceImpl, database_error, internal_receipt, owner_of, receipt_form_id,
    receipt_respondent, repository_error,
};
use crate::domain::events::{FormResponseSubmittedMetadata, FormTopicEvent};
use crate::domain::models::{
    Answer, Audience, ColumnId, Form, FormError, FormLayout, FormResponse, FormSection, MyResponse,
    RecordedResponse, Respondent, ResponseStatus, RowId, Submission, SubmissionOutcome,
};
use crate::domain::ports::{
    Clock, FormAccessDirectory, FormEventPublisher, FormImageFiles, FormsRepo,
};

/// Who a response's row is written as: the respondent, or the form's owner
/// for an anonymous visitor or on an anonymous form, so the row's author and
/// its history name nobody.
fn row_author(form: &Form, respondent: &Respondent) -> Result<MacroUserIdStr<'static>, FormError> {
    match respondent {
        Respondent::Member(user) if !form.anonymous => Ok(user.clone()),
        Respondent::Member(_) | Respondent::Anonymous => owner_of(form),
    }
}

/// The cells of a new row: every answer, then the managed columns the table
/// still has.
fn insert_cells(
    form: &Form,
    columns: &HashMap<ColumnId, QuestionColumn>,
    answered: &[AnsweredQuestion],
    respondent: &Respondent,
    submitted_at: DateTime<Utc>,
) -> Vec<CellWrite> {
    let mut cells: Vec<CellWrite> = answered
        .iter()
        .filter_map(|question| {
            question.value.clone().map(|value| CellWrite {
                column: question.column,
                value,
            })
        })
        .collect();
    if let Some(column) = writable(columns, form.submitted_column_id, submitted_kind()) {
        cells.push(CellWrite {
            column,
            value: CellValue::Date(submitted_at),
        });
    }
    if !form.anonymous
        && let (Some(column), Respondent::Member(user)) = (
            writable(columns, form.respondent_column_id, respondent_kind()),
            respondent,
        )
    {
        cells.push(CellWrite {
            column,
            value: CellValue::Entities(vec![EntityRef {
                entity_type: EntityKind::User,
                entity_id: user.to_string(),
            }]),
        });
    }
    cells
}

/// The row an insert answered.
fn inserted_row(results: &[OpResult]) -> Result<RowId, FormError> {
    results
        .iter()
        .find_map(|result| match result {
            OpResult::Rows {
                change: RowsResult::Inserted { rows },
                ..
            } => rows.first().copied(),
            _ => None,
        })
        .ok_or_else(|| FormError::DatabaseContract("an insert of one row answered no row"))
}

/// A refused write in the form's terms: an answer the databases service
/// found not to fit is that question's invalid answer.
fn write_error(error: DatabaseError, answered: &[AnsweredQuestion]) -> FormError {
    match error {
        DatabaseError::InvalidOp(refusal) => {
            match refusal.column.and_then(|column| {
                answered
                    .iter()
                    .find(|question| question.column == column)
                    .map(|question| question.question)
            }) {
                Some(question) => FormError::InvalidAnswer {
                    question,
                    reason: refusal.reason,
                },
                None => FormError::Database(DatabaseError::InvalidOp(refusal)),
            }
        }
        DatabaseError::NotFound => FormError::TableGone,
        other => database_error(other),
    }
}

/// The answers a row holds for the layout's questions.
fn answers_of(layout: &FormLayout, cells: &[CellWrite]) -> Vec<Answer> {
    let by_column: HashMap<ColumnId, &CellValue> = cells
        .iter()
        .map(|cell| (cell.column, &cell.value))
        .collect();
    layout
        .sections
        .iter()
        .flat_map(|section| match section {
            FormSection::Questions { questions, .. } => questions.as_slice(),
            FormSection::Gate { .. } | FormSection::Booking { .. } => &[],
        })
        .filter_map(|question| {
            by_column.get(&question.column).map(|value| Answer {
                question: question.id,
                value: (*value).clone(),
            })
        })
        .collect()
}

/// The layout's booking step with its destination, for a response that has
/// passed every gate and been saved.
fn unlocked_booking(layout: &FormLayout) -> Option<UnlockedBooking> {
    layout.sections.iter().find_map(|section| match section {
        FormSection::Booking {
            id,
            title,
            description,
            target,
        } => Some(UnlockedBooking {
            section: *id,
            title: title.clone(),
            description: description.clone(),
            target: target.clone(),
        }),
        FormSection::Questions { .. } | FormSection::Gate { .. } => None,
    })
}

/// Whether a saved row's answers pass the form as it is now: every required
/// question of a shown section answered and every gate passed.
fn still_passes(
    layout: &FormLayout,
    columns: &HashMap<ColumnId, QuestionColumn>,
    answers: &[Answer],
) -> bool {
    gates_fit_table(layout, columns).is_ok()
        && matches!(
            evaluate(layout, columns, answers),
            Ok(Evaluation::Passed(_))
        )
}

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 form, its table and layout for a respondent about to write:
    /// refused when it is closed, its table is gone, or it takes signed-in
    /// members only and nobody is signed in.
    async fn open_for(
        &self,
        receipt: &EntityAccessReceipt<ViewAccessLevel>,
        now: DateTime<Utc>,
    ) -> Result<(Form, Respondent, TableDetail, FormLayout), FormError> {
        let form = self.live_form(receipt_form_id(receipt)?).await?;
        if !form.accepts_responses_at(now) {
            return Err(FormError::Closed);
        }
        let respondent = receipt_respondent(receipt);
        if form.audience == Audience::Members && respondent == Respondent::Anonymous {
            return Err(FormError::SignInRequired);
        }
        let table = self.live_table_of(&form).await?;
        let layout = self.refresh_layout(&form, Some(&table)).await?.layout;
        Ok((form, respondent, table, layout))
    }

    /// Write rows under the form's receipt, as `viewer`.
    async fn write(
        &self,
        form: &Form,
        viewer: MacroUserIdStr<'static>,
        ops: Vec<DatabaseOp>,
        answered: &[AnsweredQuestion],
    ) -> Result<Vec<OpResult>, FormError> {
        self.databases
            .apply_ops(
                internal_receipt::<EditAccessLevel>(form.database_id),
                Viewer {
                    user_id: viewer,
                    acting_bot: None,
                },
                OpBatch::from(ops),
            )
            .await
            .map_err(|error| write_error(error, answered))
    }

    pub(super) async fn submit(
        &self,
        receipt: &EntityAccessReceipt<ViewAccessLevel>,
        submission: Submission,
    ) -> Result<SubmissionOutcome, FormError> {
        let now = self.now();
        let (form, respondent, table, layout) = self.open_for(receipt, now).await?;
        if let Respondent::Member(user) = &respondent {
            let responded = if form.anonymous {
                self.repository
                    .holds_receipt(form.id, user)
                    .await
                    .map_err(repository_error)?
            } else {
                self.repository
                    .response_of(form.id, user)
                    .await
                    .map_err(repository_error)?
                    .is_some_and(|entry| entry.status == ResponseStatus::Submitted)
            };
            if responded {
                return Err(FormError::AlreadyResponded);
            }
        }
        let columns = question_columns(&table);
        gates_fit_table(&layout, &columns)?;
        let answered = match evaluate(&layout, &columns, &submission.answers)? {
            Evaluation::Passed(answered) => answered,
            Evaluation::Stopped { section, message } => {
                // Only a signed-in respondent has an entry to stop; an
                // anonymous one, or anyone on an anonymous form, leaves no
                // trace.
                if let Respondent::Member(user) = &respondent
                    && !form.anonymous
                {
                    self.repository
                        .record_stop(form.id, user, section, now)
                        .await
                        .map_err(repository_error)?;
                    self.announce(form.id).await;
                }
                return Ok(SubmissionOutcome::Stopped { section, message });
            }
        };
        // An anonymous form's responses carry only their day, so their
        // times can't be matched against who was active when.
        let stamped = if form.anonymous {
            now.duration_trunc(TimeDelta::days(1))
                .map_err(|_| FormError::DatabaseContract("a submission time has no day"))?
        } else {
            now
        };
        let insert = vec![DatabaseOp::Rows {
            table: form.table_id,
            change: RowsChange::Insert {
                rows: vec![insert_cells(
                    &form,
                    &columns,
                    &answered,
                    &respondent,
                    stamped,
                )],
            },
        }];
        // The row first, under the form's receipt, then the ledger, in its
        // own transaction.
        let viewer = row_author(&form, &respondent)?;
        let results = self.write(&form, viewer, insert, &answered).await?;
        let row = inserted_row(&results)?;
        let member = match &respondent {
            Respondent::Member(user) => Some(user),
            Respondent::Anonymous => None,
        };
        let recorded = if form.anonymous {
            self.repository
                .record_anonymous_submission(form.id, member, row, stamped)
                .await
        } else {
            self.repository
                .record_submission(form.id, member, row, now)
                .await
        }
        .map_err(|error| {
                tracing::error!(error = ?error, form_id = %form.id, row_id = %row, "a response's row was written but its ledger entry was not");
                repository_error(error)
            })?;
        let response = match recorded {
            RecordedResponse::Recorded(entry) => entry.id,
            RecordedResponse::AlreadySubmitted => {
                // A concurrent submission by the same person won the
                // one-per-person key; this row stays in the table.
                tracing::error!(form_id = %form.id, row_id = %row, "a duplicate response's row was written; the respondent already had an accepted response");
                return Err(FormError::AlreadyResponded);
            }
        };
        self.announce(form.id).await;
        self.emit(FormTopicEvent::ResponseSubmitted(
            FormResponseSubmittedMetadata {
                form_id: form.id,
                response_id: response,
                // An anonymous form's event names nobody; activity would
                // say who responded.
                respondent: match respondent {
                    Respondent::Member(user) if !form.anonymous => Some(user),
                    Respondent::Member(_) | Respondent::Anonymous => None,
                },
                row_id: Some(row),
                submitted_at: stamped,
            },
        ));
        Ok(SubmissionOutcome::Submitted {
            response,
            row,
            booking: unlocked_booking(&layout),
        })
    }

    pub(super) async fn edit(
        &self,
        receipt: &EntityAccessReceipt<ViewAccessLevel>,
        submission: Submission,
    ) -> Result<SubmissionOutcome, FormError> {
        let now = self.now();
        let Respondent::Member(user) = receipt_respondent(receipt) else {
            return Err(FormError::SignInRequired);
        };
        let (form, _, table, layout) = self.open_for(receipt, now).await?;
        if form.anonymous {
            return Err(FormError::AnonymousResponseFinal);
        }
        let entry = self
            .repository
            .response_of(form.id, &user)
            .await
            .map_err(repository_error)?
            .filter(|entry| entry.status == ResponseStatus::Submitted)
            .ok_or(FormError::NoResponse)?;
        let columns = question_columns(&table);
        gates_fit_table(&layout, &columns)?;
        let answered = match evaluate(&layout, &columns, &submission.answers)? {
            Evaluation::Passed(answered) => answered,
            // The saved response stays as it was.
            Evaluation::Stopped { section, message } => {
                return Ok(SubmissionOutcome::Stopped { section, message });
            }
        };
        let row = match self.held_row(&form, entry.row).await? {
            Some(row) => {
                self.rewrite_row(&form, &user, row, &answered).await?;
                self.repository
                    .touch_response(entry.id, now)
                    .await
                    .map_err(repository_error)?;
                row
            }
            None => {
                self.rewrite_lost_row(&form, &columns, &user, &entry, &answered, now)
                    .await?
            }
        };
        self.announce(form.id).await;
        Ok(SubmissionOutcome::Submitted {
            response: entry.id,
            row,
            booking: unlocked_booking(&layout),
        })
    }

    /// The entry's row, if it is still in the table.
    async fn held_row(&self, form: &Form, row: Option<RowId>) -> Result<Option<RowId>, FormError> {
        let Some(row) = row else {
            return Ok(None);
        };
        let cells = self
            .databases
            .cells_of_rows(
                internal_receipt::<ViewAccessLevel>(form.database_id),
                form.table_id,
                &[row],
            )
            .await
            .map_err(|error| match error {
                DatabaseError::NotFound => FormError::TableGone,
                other => database_error(other),
            })?;
        Ok(cells.contains_key(&row).then_some(row))
    }

    /// Write every question's answer to the row, clearing the unanswered.
    async fn rewrite_row(
        &self,
        form: &Form,
        user: &MacroUserIdStr<'static>,
        row: RowId,
        answered: &[AnsweredQuestion],
    ) -> Result<(), FormError> {
        let cells = answered
            .iter()
            .map(|question| CellWrite {
                column: question.column,
                value: question.value.clone().unwrap_or(CellValue::Clear),
            })
            .collect();
        self.write(
            form,
            row_author(form, &Respondent::Member(user.clone()))?,
            vec![DatabaseOp::Rows {
                table: form.table_id,
                change: RowsChange::Update {
                    changes: RowChanges::PerRow {
                        rows: vec![RowChange { row, cells }],
                    },
                },
            }],
            answered,
        )
        .await
        .map(|_| ())
    }

    /// The entry's row was deleted from the table: write a new one, stamped
    /// with the original submission time, and point the entry at it.
    async fn rewrite_lost_row(
        &self,
        form: &Form,
        columns: &HashMap<ColumnId, QuestionColumn>,
        user: &MacroUserIdStr<'static>,
        entry: &FormResponse,
        answered: &[AnsweredQuestion],
        now: DateTime<Utc>,
    ) -> Result<RowId, FormError> {
        let insert = vec![DatabaseOp::Rows {
            table: form.table_id,
            change: RowsChange::Insert {
                rows: vec![insert_cells(
                    form,
                    columns,
                    answered,
                    &Respondent::Member(user.clone()),
                    entry.submitted_at,
                )],
            },
        }];
        let viewer = row_author(form, &Respondent::Member(user.clone()))?;
        let results = self.write(form, viewer, insert, answered).await?;
        let row = inserted_row(&results)?;
        self.repository
            .repoint_response(entry.id, row, now)
            .await
            .map_err(|error| {
                tracing::error!(error = ?error, form_id = %form.id, row_id = %row, response_id = %entry.id, "a response's new row was written but its ledger entry was not repointed");
                repository_error(error)
            })?;
        Ok(row)
    }

    pub(super) async fn own_response(
        &self,
        receipt: &EntityAccessReceipt<ViewAccessLevel>,
    ) -> Result<MyResponse, FormError> {
        let Respondent::Member(user) = receipt_respondent(receipt) else {
            return Err(FormError::SignInRequired);
        };
        let form = self.live_form(receipt_form_id(receipt)?).await?;
        if form.anonymous {
            return if self
                .repository
                .holds_receipt(form.id, &user)
                .await
                .map_err(repository_error)?
            {
                Ok(MyResponse::Anonymous)
            } else {
                Err(FormError::NoResponse)
            };
        }
        let response = Box::new(
            self.repository
                .response_of(form.id, &user)
                .await
                .map_err(repository_error)?
                .ok_or(FormError::NoResponse)?,
        );
        let Some(row) = response.row else {
            return Ok(MyResponse::Saved {
                response,
                answers: vec![],
                booking: None,
            });
        };
        // A table gone, or its database in the trash, leaves the receipt
        // with no answers to show.
        let mut cells = match self
            .databases
            .cells_of_rows(
                internal_receipt::<ViewAccessLevel>(form.database_id),
                form.table_id,
                &[row],
            )
            .await
        {
            Ok(cells) => cells,
            Err(DatabaseError::NotFound) => {
                return Ok(MyResponse::Saved {
                    response,
                    answers: vec![],
                    booking: None,
                });
            }
            Err(other) => return Err(database_error(other)),
        };
        let table = self.table_of(&form).await?;
        let layout = self.refresh_layout(&form, table.as_ref()).await?.layout;
        let Some(cells) = cells.remove(&row) else {
            return Ok(MyResponse::Saved {
                response,
                answers: vec![],
                booking: None,
            });
        };
        let answers = answers_of(&layout, &cells);
        let passes = response.status == ResponseStatus::Submitted
            && match table {
                Some(table) => still_passes(&layout, &question_columns(&table), &answers),
                None => false,
            };
        Ok(MyResponse::Saved {
            response,
            answers,
            booking: passes.then(|| unlocked_booking(&layout)).flatten(),
        })
    }
}