Meridian Forms — формы и опросы

<form xmlns="urn:meridian:office:forms:1" id="01J9X0.." version="3" lang="ru" title="Опрос сотрудников 2026"
      mode="survey" theme="theme.xml" progress="bar" numbering="true" one-question-per-page="false" shuffle-pages="false">
  <settings>
    <access who="organization" one-response="true" anonymous="false" allow-edit="true" show-summary="false"/>
    <limits max-responses="500" closes="2026-11-01T00:00:00Z"/>
    <messages start="Ответы займут 5 минут" thanks="Спасибо! Ваш ответ сохранён." closed="Приём ответов завершён"/>
    <notify on-response="hub" digest="daily"/>
  </settings>
  <page id="p1" title="О вас">
    <question id="q1" type="single-choice" required="true" shuffle="true">
      <text>В каком отделе вы работаете?</text>
      <option id="o1">Продажи</option><option id="o2">Разработка</option><option id="o3">Поддержка</option>
      <option id="o9" other="true">Другое</option>
    </question>
    <question id="q2" type="nps" required="true"><text>Насколько вероятно, что вы порекомендуете компанию как работодателя?</text>
      <scale min="0" max="10" min-label="Маловероятно" max-label="Очень вероятно"/></question>
  </page>
  <page id="p2" title="Поддержка">
    <question id="q3" type="likert" show-if="{q1} = 'o3'">
      <text>Оцените утверждения</text>
      <rows><row id="r1">Инструменты удобны</row><row id="r2">Нагрузка посильна</row></rows>
      <columns><col id="c1" value="1">Не согласен</col><col id="c2" value="2"/><col id="c3" value="3"/><col id="c4" value="4"/><col id="c5" value="5">Согласен</col></columns>
    </question>
    <question id="q4" type="long-text" required="false" max-length="2000"><text>Что улучшить? {q1}</text></question>
  </page>
  <page id="p3" title="Тест по безопасности">
    <question id="q5" type="multi-choice" points="2" partial="true">
      <text>Какие пароли надёжны?</text>
      <option id="a1" correct="true">tr0ub4dor&amp;3-horse-battery</option><option id="a2">123456</option><option id="a3" correct="true">фраза из пяти слов</option>
      <explanation>Надёжны длинные фразы.</explanation>
    </question>
    <question id="q6" type="short-text" subtype="email" required="true" validation="regex" pattern="^[^@]+@company\.ru$" message="Укажите корпоративный адрес"/>
  </page>
  <logic>
    <!-- Правила перехода: оцениваются по порядку после страницы / Jump rules evaluated in order after a page -->
    <rule after="p1" if="{q1} = 'o3'" goto="p2"/>
    <rule after="p1" if="{q2} &lt;= 6" goto="p2"/>
    <rule after="p1" goto="p3"/>                    <!-- без условия = по умолчанию / default -->
    <rule after="p2" goto="p3"/>
    <rule after="p3" goto="end"/>
    <computed id="c_score_pct" expr="=ROUND({score} / {max_score} * 100)"/>
  </logic>
  <scoring enabled="true" pass="60" show-result="immediately" time-limit="PT20M"/>
</form>

<responses xmlns="urn:meridian:office:forms:1" form="01J9X0.." source="cloud" exported="2026-10-03T10:00:00Z">
  <response id="01J9X5.." form-version="3" started="2026-10-02T09:12:03Z" submitted="2026-10-02T09:17:40Z" lang="ru"
            status="complete" respondent="user:01J8..|anon|email:ivan@company.ru" channel="cloud|mail|pdf|kiosk|import|manual"
            score="7" max-score="10" passed="true" path="p1,p2,p3">
    <answer q="q1"><choice>o3</choice></answer>
    <answer q="q2"><number>8</number></answer>
    <answer q="q3"><cell row="r1" col="c4"/><cell row="r2" col="c2"/></answer>
    <answer q="q4"><text>Нужен второй монитор.</text></answer>
    <answer q="q5"><choice>a1</choice><choice>a3</choice></answer>
    <answer q="q6"><text>ivan@company.ru</text></answer>
    <meta key="ua">…</meta>                      <!-- только при включённом сборе / only when enabled -->
  </response>
</responses>

// kernel/crates/meridian-forms/src/model.rs
pub struct Form { pub id: Ulid, pub version: u32, pub title: LString, pub settings: Settings, pub pages: Vec<Page>,
                  pub logic: Logic, pub scoring: Option<Scoring>, pub theme: Theme, pub langs: Vec<Lang> }
pub struct Page { pub id: Id, pub title: LString, pub questions: Vec<Question>, pub show_if: Option<Expr> }
pub struct Question {
    pub id: Id, pub kind: QuestionKind, pub text: LString, pub description: Option<LString>, pub media: Option<MediaRef>,
    pub required: bool, pub show_if: Option<Expr>, pub validation: Validation, pub shuffle: bool,
    pub points: Option<f64>, pub partial: bool, pub explanation: Option<LString>,
}
pub enum QuestionKind {
    ShortText { subtype: TextSubtype, max_len: Option<u32> }, LongText { max_len: Option<u32> },
    SingleChoice { options: Vec<Option_>, other: bool, layout: Layout }, MultiChoice { options: Vec<Option_>, other: bool, min: Option<u8>, max: Option<u8> },
    Dropdown { options: Vec<Option_> }, Scale { min: i8, max: i8, step: u8, labels: (LString, LString) }, Rating { max: u8, icon: RatingIcon },
    Date, Time, DateTime, Number { min: Option<f64>, max: Option<f64>, step: Option<f64>, integer: bool },
    File { types: Vec<String>, max_size: u64, max_count: u8 }, Likert { rows: Vec<Row>, cols: Vec<Col>, na: bool },
    Ranking { options: Vec<Option_>, top_n: Option<u8> }, Matrix { rows: Vec<Row>, cols: Vec<Col>, multi: bool },
    Nps, YesNo, Signature, Section, PageBreak, Description, Consent { text: LString, link: Option<Url> }, Hidden { param: String },
}
pub struct Option_ { pub id: Id, pub text: LString, pub image: Option<MediaRef>, pub correct: bool, pub exclusive: bool }
pub struct Logic { pub rules: Vec<JumpRule>, pub computed: Vec<Computed> }
pub struct JumpRule { pub after: Id /* page */, pub cond: Option<Expr>, pub target: Target /* Page(Id) | Question(Id) | End(Option<LString>) */ }

pub enum AnswerValue { Choice(Vec<Id>), Other(String), Text(String), Number(f64), Date(NaiveDate), Time(NaiveTime), DateTime(DateTime<Utc>),
                       Cells(Vec<(Id, Id)>), Ranking(Vec<Id>), Files(Vec<MediaRef>), Signature(MediaRef), Bool(bool), Empty }
pub struct Response { pub id: Ulid, pub form_version: u32, pub started: Timestamp, pub submitted: Option<Timestamp>, pub status: Status,
                      pub respondent: Respondent, pub channel: Channel, pub lang: Lang, pub answers: BTreeMap<Id, AnswerValue>,
                      pub score: Option<Score>, pub path: Vec<Id>, pub meta: BTreeMap<String, String> }

CREATE TABLE forms (id TEXT PRIMARY KEY, path TEXT, title TEXT, version INTEGER, published INTEGER, cloud_id TEXT, responses INTEGER, last_response INTEGER);
CREATE TABLE responses (id TEXT PRIMARY KEY, form_id TEXT, form_version INTEGER, submitted INTEGER, channel TEXT, respondent TEXT, status TEXT, score REAL, lang TEXT);
CREATE TABLE answers (response_id TEXT REFERENCES responses(id) ON DELETE CASCADE, q TEXT, kind TEXT, v_text TEXT, v_num REAL, v_id TEXT, row_id TEXT, col_id TEXT);
CREATE INDEX answers_q ON answers(q, v_id); CREATE INDEX answers_num ON answers(q, v_num);
CREATE TABLE sync_state (form_id TEXT PRIMARY KEY, cloud_cursor TEXT, mail_folder TEXT, last_sync INTEGER);
CREATE TABLE dedupe (form_id TEXT, fingerprint BLOB, response_id TEXT, PRIMARY KEY(form_id, fingerprint));

pub fn check_logic(form: &Form) -> Vec<LogicIssue> {
    let g = build_graph(form);                       // adjacency: page → [(cond, target)]
    let mut issues = vec![];
    // 1. Циклы — DFS с тремя цветами; цикл допустим только если на нём есть условное ребро,
    //    но и тогда предупреждение «возможный бесконечный маршрут» / cycles: DFS, 3 colours
    let mut colour = HashMap::new();
    fn dfs(n: Id, g: &Graph, colour: &mut HashMap<Id, u8>, stack: &mut Vec<Id>, issues: &mut Vec<LogicIssue>) {
        colour.insert(n, 1); stack.push(n);
        for (cond, t) in &g[&n] {
            match colour.get(t).copied().unwrap_or(0) {
                0 => dfs(*t, g, colour, stack, issues),
                1 => issues.push(if cond.is_none() { LogicIssue::Cycle(stack.clone(), *t) } else { LogicIssue::PossibleLoop(stack.clone(), *t) }),
                _ => {}
            }
        }
        stack.pop(); colour.insert(n, 2);
    }
    let mut stack = vec![]; dfs(START, &g, &mut colour, &mut stack, &mut issues);
    // 2. Недостижимые страницы — всё, что не покрашено после DFS от start / unreachable = not visited
    for p in &form.pages { if !colour.contains_key(&p.id) { issues.push(LogicIssue::Unreachable(p.id)); } }
    // 3. Нет пути к end (тупики: страница без исходящих рёбер, кроме end) / dead ends
    for (n, edges) in &g { if edges.is_empty() && *n != END { issues.push(LogicIssue::DeadEnd(*n)); } }
    // 4. Условие ссылается на вопрос, который может быть не отвечен на всех путях к этой точке
    //    / condition references a question possibly unanswered on some path
    for (n, edges) in &g { for (cond, _) in edges { if let Some(c) = cond { for q in c.question_refs() {
        if !dominates(&g, page_of(form, q), *n) { issues.push(LogicIssue::MaybeUnanswered { at: *n, q }); } } } } }
    // 5. Обязательный вопрос на недостижимой странице, правило «по умолчанию» не последнее (затеняет), пустые ветви "other"
    issues.extend(static_checks(form, &g));
    issues
}

interface FormsApp {
  form: Form | null;                                 // активная форма / active form
  open(path: string): Promise<Form>; create(title: string, opts?: { template?: string }): Promise<Form>;
  on(event: 'responseReceived' | 'formPublished' | 'formClosed', h: (e: { form: Form; response?: Response }) => void): Disposable;
}
interface Form {
  id: string; title: string; version: number; pages: Page[]; questions: Question[]; logic: Logic; settings: Settings; theme: Theme; languages: string[];
  addPage(title?: string, at?: number): Page; question(id: string): Question | null;
  validate(): LogicIssue[]; preview(device?: 'desktop'|'tablet'|'phone'): void;
  publish(opts?: { channel: 'cloud'; close?: Date }): Promise<{ url: string; qr: Blob }>; unpublish(): Promise<void>;
  exportPdf(path: string, opts?: { fillable?: boolean; lang?: string }): Promise<void>;
  responses: Responses; translations: Translations; save(): Promise<void>;
}
interface Page { id: string; title: string; questions: Question[]; addQuestion(type: QuestionType, text: string, opts?: Partial<QuestionProps>): Question; }
interface Question { id: string; type: QuestionType; text: string; required: boolean; options: Option[]; showIf: string | null; points: number | null;
  addOption(text: string, opts?: { correct?: boolean }): Option; remove(): void; moveTo(page: Page, index?: number): void; }
interface Logic { rules: JumpRule[]; addRule(after: Page, target: Page | 'end', condition?: string): JumpRule; computed: Computed[]; }
interface Responses {
  count: number; list(filter?: { since?: Date; channel?: string; where?: string }): Promise<Response[]>;
  summary(questionId: string): Promise<Summary>; import(path: string): Promise<ImportReport>;
  export(path: string, format: 'xlsx'|'csv'|'msx'|'json'|'pdf'): Promise<void>; openInSheets(): Promise<void>;
  add(answers: Record<string, unknown>, opts?: { channel?: 'manual'; respondent?: string }): Promise<Response>;
  grade(responseId: string, questionId: string, points: number, comment?: string): Promise<void>;
}
interface Response { id: string; submitted: Date; channel: string; respondent: string | null; answers: Record<string, unknown>; score: number | null; passed: boolean | null; }

// 1. Письмо с благодарностью и результатом теста после каждого ответа / Thank-you mail with test result
App.on('responseReceived', async ({ form, response }) => {
  if (!response?.respondent?.startsWith('email:')) return;
  await Meridian.mail.send({ to: response.respondent.slice(6), subject: `Результат: ${form.title}`,
    body: `Ваш балл: ${response.score} (${response.passed ? 'зачёт' : 'незачёт'})` });
});

// 2. Собрать форму из списка вопросов в Sheets / Build a form from a Sheets range
const rows = await Meridian.sheets.active!.range('Вопросы!A2:C50').values();
const f = await App.create('Опрос из таблицы');
const p = f.addPage('Вопросы');
for (const [text, type, opts] of rows.filter(r => r[0])) {
  const q = p.addQuestion(type as QuestionType, String(text), { required: true });
  for (const o of String(opts ?? '').split('|').filter(Boolean)) q.addOption(o);
}
const issues = f.validate(); if (issues.length) await Meridian.ui.message(issues.map(i => i.message).join('\n'));
await f.save();

// 3. Еженедельный экспорт ответов в Sheets-файл / Weekly export to a Sheets file
await App.form!.responses.export('~/Отчёты/ответы.msx', 'msx');