@adcops/autocore-react 3.5.15 → 3.6.3

package/src/components/tis-editor/DeleteMethodDialog.tsx

@@ -0,0 +1,162 @@
+/**
+ * DeleteMethodDialog — the three-step method deletion.
+ *
+ * Deleting a test method destroys more than a config entry. It takes the
+ * procedure that produced the numbers with it, and it orphans every run in
+ * history from the schema that gives those runs meaning: the column names, the
+ * units, the chart definitions. A `window.confirm` is not a proportionate gate
+ * on that.
+ *
+ * So the operator walks three steps and cannot skip any of them:
+ *
+ *   1. Read what goes.       Named, counted, and explicit about the history.
+ *   2. Download the archive. MANDATORY, not advisory. `tis.export_method_zip`
+ *                            hands back every run of this method. The button
+ *                            gates step 3, so "I'll do it later" is not a
+ *                            path through this dialog.
+ *   3. Type the phrase.      `YES I AM SURE`, exactly. A phrase cannot be
+ *                            hit by a mis-touch on a panel, and typing it is
+ *                            the moment the operator reads step 1 properly.
+ *
+ * The deletion itself is still STAGED — the TIS editor's Save is what persists
+ * it — but the sequence file and the operator's confidence are not, so this is
+ * where the friction belongs.
+ */
+
+import { useEffect, useState } from 'react';
+import { Button } from 'primereact/button';
+import { Dialog } from 'primereact/dialog';
+import { InputText } from 'primereact/inputtext';
+import { Message } from 'primereact/message';
+
+/** Typed exactly, case-sensitive. */
+export const DELETE_PHRASE = 'YES I AM SURE';
+
+export interface DeleteMethodDialogProps {
+    visible: boolean;
+    methodId: string | null;
+    /** True when this method's procedure is a file that will also be removed. */
+    hasSequence: boolean;
+    /**
+     * Fetch the archive of this method's runs and hand it to the browser.
+     * Resolves true once the download has been started.
+     */
+    onDownloadArchive: (methodId: string) => Promise<boolean>;
+    onConfirm: () => void;
+    onCancel: () => void;
+    busy?: boolean;
+}
+
+export const DeleteMethodDialog: React.FC<DeleteMethodDialogProps> = ({
+    visible,
+    methodId,
+    hasSequence,
+    onDownloadArchive,
+    onConfirm,
+    onCancel,
+    busy,
+}) => {
+    const [archived, setArchived] = useState(false);
+    const [downloading, setDownloading] = useState(false);
+    const [phrase, setPhrase] = useState('');
+    const [error, setError] = useState<string | null>(null);
+
+    // Reset every time the dialog opens, and key on the method: reusing the
+    // "already archived" flag across two different methods would let the second
+    // one out of step 2 on the strength of the first one's download.
+    useEffect(() => {
+        if (visible) {
+            setArchived(false);
+            setDownloading(false);
+            setPhrase('');
+            setError(null);
+        }
+    }, [visible, methodId]);
+
+    const doDownload = async () => {
+        if (!methodId) return;
+        setDownloading(true);
+        setError(null);
+        try {
+            const ok = await onDownloadArchive(methodId);
+            setArchived(ok);
+            if (!ok) setError('The archive could not be built, so nothing has been deleted.');
+        } catch (e) {
+            setError(`The archive could not be built, so nothing has been deleted: ${
+                e instanceof Error ? e.message : String(e)}`);
+        } finally {
+            setDownloading(false);
+        }
+    };
+
+    const phraseOk = phrase === DELETE_PHRASE;
+
+    return (
+        <Dialog
+            header={`Delete test method "${methodId ?? ''}"`}
+            visible={visible}
+            onHide={onCancel}
+            style={{ width: '34rem' }}
+            modal
+        >
+            <ol className="tis-editor__delete-steps">
+                <li>
+                    <strong>What this removes</strong>
+                    <ul>
+                        <li>The method definition: its fields, charts, results and asset references.</li>
+                        {hasSequence && <li>Its sequence — the procedure that runs the test.</li>}
+                        <li>
+                            Nothing in the recorded data is erased, but every past run of this
+                            method loses the definition that names its columns. Reports and
+                            charts for those runs will no longer render.
+                        </li>
+                    </ul>
+                </li>
+
+                <li>
+                    <strong>Download the archive</strong>
+                    <p>
+                        Every run recorded under this method, as a ZIP. This is required — the
+                        confirmation below stays locked until the download has started.
+                    </p>
+                    <Button
+                        label={archived ? 'Archive downloaded' : 'Download archive'}
+                        icon={downloading ? 'pi pi-spin pi-spinner' : archived ? 'pi pi-check' : 'pi pi-box'}
+                        severity={archived ? 'success' : undefined}
+                        disabled={downloading || busy}
+                        onClick={doDownload}
+                    />
+                </li>
+
+                <li>
+                    <strong>Confirm</strong>
+                    <p>
+                        Type <code>{DELETE_PHRASE}</code> to enable the delete button.
+                    </p>
+                    <InputText
+                        value={phrase}
+                        onChange={(e) => setPhrase(e.target.value)}
+                        placeholder={DELETE_PHRASE}
+                        disabled={!archived || busy}
+                        style={{ width: '100%' }}
+                    />
+                </li>
+            </ol>
+
+            {error && <Message severity="error" text={error} style={{ width: '100%' }} />}
+
+            <div style={{ display: 'flex', gap: '0.5rem', justifyContent: 'flex-end', marginTop: '1rem' }}>
+                <Button label="Cancel" className="p-button-text" onClick={onCancel} disabled={busy} />
+                <Button
+                    label="Delete method"
+                    icon="pi pi-trash"
+                    className="p-button-danger"
+                    disabled={!archived || !phraseOk || busy}
+                    onClick={onConfirm}
+                />
+            </div>
+        </Dialog>
+    );
+};
+
+export default DeleteMethodDialog;

package/src/components/tis-editor/MethodTransfer.ts

@@ -0,0 +1,138 @@
+/**
+ * MethodTransfer — a whole test method as one portable file.
+ *
+ * ## Why the method and not the sequence
+ *
+ * A sequence-backed method is two halves with a contract between them: the
+ * schema declares the cycle columns, and the procedure's `store_value` steps
+ * fill them by name. Exporting either half alone produces something that looks
+ * like a method and silently is not — a schema with no producer records blank
+ * rows on every cycle forever, and a procedure with no schema stores values
+ * nothing displays. Neither failure announces itself.
+ *
+ * So the exportable unit is the pair. This is the same reasoning that made
+ * `acctl push methods` move both files with one verb.
+ *
+ * ## The file
+ *
+ * Plain JSON, human-readable, no archive container: it goes on a USB stick
+ * between companies and someone will open it in a text editor.
+ *
+ *     {
+ *       "format": "autocore-method",
+ *       "version": 1,
+ *       "method_id": "golf_compression",
+ *       "schema":   { ...test_methods.json entry... },
+ *       "sequence": { ...seq.json..., or null for a control-backed method }
+ *     }
+ *
+ * `method_id` is a SUGGESTION, not an instruction. The importer offers it and
+ * lets the operator rename, because a method list that fills up with
+ * `golf_compression_copy_3` is the complaint that follows otherwise.
+ */
+
+import type { TestMethod } from './types';
+
+export const METHOD_FILE_FORMAT = 'autocore-method';
+export const METHOD_FILE_VERSION = 1;
+
+export interface MethodTransferFile {
+    format: typeof METHOD_FILE_FORMAT;
+    version: number;
+    method_id: string;
+    schema: TestMethod;
+    /** The procedure, or null for a control-backed method. */
+    sequence: any | null;
+}
+
+/** Build the export payload. */
+export function buildTransfer(
+    methodId: string,
+    schema: TestMethod,
+    sequence: any | null,
+): MethodTransferFile {
+    return {
+        format: METHOD_FILE_FORMAT,
+        version: METHOD_FILE_VERSION,
+        method_id: methodId,
+        schema,
+        sequence: sequence ?? null,
+    };
+}
+
+/**
+ * Legal method ids, and why the rule is this strict.
+ *
+ * The id becomes a path segment (`methods/<id>.seq.json`) and a directory name
+ * under the project (`<project>/<method_id>/<run_id>/`), both joined
+ * server-side, so anything that could traverse or quote-escape is refused at
+ * entry rather than sanitised silently — an id that comes back different from
+ * what was typed is how you end up with two methods you believe are one.
+ *
+ * It is also a Rust identifier stem in generated code, hence the leading-letter
+ * rule: `2point_bend` would emit `2pointBendTestManager`, which does not
+ * compile.
+ */
+export const METHOD_ID_RE = /^[A-Za-z][A-Za-z0-9_]*$/;
+export const METHOD_ID_RULE =
+    'Letters, digits and underscore only; must start with a letter.';
+
+/** Parse and validate an imported file. Returns the file or a reason. */
+export function parseTransfer(text: string): { file: MethodTransferFile } | { error: string } {
+    let parsed: unknown;
+    try {
+        parsed = JSON.parse(text);
+    } catch (e) {
+        return { error: `Not valid JSON: ${e instanceof Error ? e.message : String(e)}` };
+    }
+    if (typeof parsed !== 'object' || parsed === null) {
+        return { error: 'File does not contain a method object.' };
+    }
+    const f = parsed as Partial<MethodTransferFile>;
+    if (f.format !== METHOD_FILE_FORMAT) {
+        // Name what it looks like. A `.seq.json` dropped here is the most
+        // likely wrong file, and "unrecognised format" would leave the operator
+        // with no idea which of their two files to reach for.
+        const looksLikeSequence = Array.isArray((parsed as any)?.steps);
+        return {
+            error: looksLikeSequence
+                ? 'This is a sequence file, not a whole method. Import it from a method export, '
+                  + 'or create the method first and edit its sequence on the Method screen.'
+                : 'Not an autocore method export (missing "format": "autocore-method").',
+        };
+    }
+    if (typeof f.version !== 'number' || f.version > METHOD_FILE_VERSION) {
+        return {
+            error: `This file was written by a newer version (v${f.version}); `
+                 + `this machine understands up to v${METHOD_FILE_VERSION}.`,
+        };
+    }
+    if (typeof f.method_id !== 'string' || !METHOD_ID_RE.test(f.method_id)) {
+        return { error: `File has no usable method id. ${METHOD_ID_RULE}` };
+    }
+    if (typeof f.schema !== 'object' || f.schema === null) {
+        return { error: 'File has no method schema.' };
+    }
+    // A sequence-backed method with no procedure in the file is a half export;
+    // refuse it rather than importing a method that cannot run.
+    if ((f.schema as TestMethod).procedure === 'sequence' && !Array.isArray(f.sequence?.steps)) {
+        return {
+            error: 'This method declares a sequence procedure but the file carries no sequence. '
+                 + 'Re-export it from the machine it came from.',
+        };
+    }
+    return { file: f as MethodTransferFile };
+}
+
+/** Hand the browser a method export to save. */
+export function downloadTransfer(file: MethodTransferFile): void {
+    const blob = new Blob([JSON.stringify(file, null, 2)], { type: 'application/json' });
+    const url = URL.createObjectURL(blob);
+    const a = document.createElement('a');
+    a.href = url;
+    a.download = `${file.method_id}.method.json`;
+    a.click();
+    // Revoke on the next tick: revoking synchronously can beat the download in
+    // Chromium, which is the browser on every panel.
+    setTimeout(() => URL.revokeObjectURL(url), 0);
+}

package/src/components/tis-editor/TisConfigEditor.css

@@ -150,3 +150,34 @@
         border-bottom: 1px solid var(--surface-d, #e2e8f0);
     }
 }
+
+/*
+ * The three-step method deletion. Numbered because the steps are ordered and
+ * gated: the archive download unlocks the confirmation phrase, which unlocks
+ * the button. See DeleteMethodDialog for why deleting a method earns this.
+ */
+.tis-editor__delete-steps {
+    margin: 0 0 1rem;
+    padding-left: 1.4rem;
+}
+
+.tis-editor__delete-steps > li {
+    margin-bottom: 1rem;
+}
+
+.tis-editor__delete-steps p {
+    margin: 0.35rem 0 0.5rem;
+}
+
+.tis-editor__delete-steps ul {
+    margin: 0.35rem 0 0;
+    padding-left: 1.1rem;
+}
+
+.tis-editor__delete-steps code {
+    padding: 0.1rem 0.35rem;
+    border-radius: 3px;
+    background: var(--surface-ground);
+    font-family: var(--font-family-mono, monospace);
+    letter-spacing: 0.04em;
+}