Introduce editable table for creating score distributions

app/assets/javascripts/components/input_table.ts

@@ -0,0 +1,244 @@
+import { customElement, property } from "lit/decorators.js";
+import { html, PropertyValues, TemplateResult } from "lit";
+import jspreadsheet, { Column, JspreadsheetInstance } from "jspreadsheet-ce";
+import { createRef, ref, Ref } from "lit/directives/ref.js";
+import { DodonaElement } from "components/meta/dodona_element";
+import { fetch, ready } from "utilities";
+import { i18n } from "i18n/i18n";
+import { Tooltip } from "bootstrap";
+
+type CellData = string | number | boolean;
+type ScoreItem = {
+    id: number | null;
+    name: string;
+    description?: string;
+    maximum: string;
+    visible: boolean;
+    order?: number;
+}
+
+type ColumnWithTooltip = Column & { tooltip?: string };
+
+/**
+ * A spreadsheet table to edit score items.
+ *
+ * @element d-score-item-input-table
+ *
+ * @fires cancel - When the cancel button is clicked.
+ *
+ * @prop {string} route - The route to send the updated score items to.
+ * @prop {ScoreItem[]} scoreItems - The original score items, that will be displayed in the table.
+ */
+@customElement("d-score-item-input-table")
+export class ScoreItemInputTable extends DodonaElement {
+    @property({ type: String })
+    route: string = "";
+    @property({ type: Array, attribute: "score-items" })
+    scoreItems: ScoreItem[] = [];
+
+    tableRef: Ref<HTMLDivElement> = createRef();
+    table: JspreadsheetInstance;
+
+    @property({ state: true })
+    hasErrors: boolean = false;
+
+    get tableWidth(): number {
+        return this.tableRef.value.clientWidth;
+    }
+
+    get descriptionColWidth(): number {
+        if (!this.tableRef.value) {
+            return 200;
+        }
+
+        // full width - borders - name column - maximum column - visible column - index column
+        const variableWidth = this.tableWidth - 14 - 200 - 100 - 100 - 50;
+        return Math.max(200, variableWidth);
+    }
+
+    get data(): CellData[][] {
+        return [
+            ...this.scoreItems.map(item => [
+                item.id,
+                item.name,
+                item.description,
+                item.maximum,
+                item.visible
+            ]),
+            ["", "", "", "", false]
+        ];
+    }
+
+    get editedScoreItems(): ScoreItem[] {
+        const tableData = this.table.getData();
+
+        const scoreItems = tableData.map((row: CellData[], index: number) => {
+            return {
+                id: row[0] as number | null,
+                name: row[1] as string,
+                description: row[2] as string,
+                maximum: (row[3] as string).replace(",", "."), // replace comma with dot for float representation
+                visible: row[4] as boolean,
+                order: index,
+            };
+        });
+
+        // filter out empty rows
+        return scoreItems.filter(item => !(item.name === "" && item.maximum === "" && item.description === "" && item.visible === false));
+    }
+
+    get columnConfig(): ColumnWithTooltip[] {
+        return [
+            { type: "hidden", title: "id" },
+            { type: "text", title: i18n.t("js.score_items.name"), width: 200, align: "left" },
+            { type: "text", title: i18n.t("js.score_items.description"), width: this.descriptionColWidth, align: "left", tooltip: i18n.t("js.score_items.description_help") },
+            { type: "numeric", title: i18n.t("js.score_items.maximum"), width: 100, align: "left", tooltip: i18n.t("js.score_items.maximum_help") },
+            { type: "checkbox", title: i18n.t("js.score_items.visible"), width: 100, align: "left", tooltip: i18n.t("js.score_items.visible_help") },
+        ];
+    }
+
+    async initTable(): Promise<void> {
+        // Wait for translations to be present
+        await ready;
+
+        this.table = jspreadsheet(this.tableRef.value, {
+            root: this,
+            data: this.data,
+            columns: this.columnConfig,
+            text: {
+                copy: i18n.t("js.score_items.jspreadsheet.copy"),
+                deleteSelectedRows: i18n.t("js.score_items.jspreadsheet.deleteSelectedRows"),
+                insertANewRowAfter: i18n.t("js.score_items.jspreadsheet.insertNewRowAfter"),
+                insertANewRowBefore: i18n.t("js.score_items.jspreadsheet.insertNewRowBefore"),
+                paste: i18n.t("js.score_items.jspreadsheet.paste"),
+            },
+            about: false,
+            allowDeleteColumn: false,
+            allowDeleteRow: true,
+            allowInsertColumn: false,
+            allowInsertRow: true,
+            allowManualInsertColumn: false,
+            allowManualInsertRow: true,
+            allowRenameColumn: false,
+            columnResize: false,
+            columnSorting: false,
+            minSpareRows: 1,
+            parseFormulas: false,
+            selectionCopy: false,
+            wordWrap: true,
+            defaultRowHeight: 30,
+            allowExport: false,
+        });
+
+        // init tooltips
+        this.columnConfig.forEach((column, index) => {
+            const td = this.tableRef.value.querySelector(`thead td[data-x="${index}"]`);
+            if (td && column.tooltip) {
+                td.setAttribute("title", column.tooltip);
+                new Tooltip(td);
+            }
+        });
+
+
+        // update description column width when the window is resized
+        new ResizeObserver(() => {
+            this.table.setWidth(2, this.descriptionColWidth);
+        }).observe(this.tableRef.value);
+    }
+
+    protected firstUpdated(_changedProperties: PropertyValues): void {
+        super.firstUpdated(_changedProperties);
+
+        this.initTable();
+    }
+
+    validate(): boolean {
+        // Remove all error classes
+        this.tableRef.value.querySelectorAll("td.error").forEach(cell => {
+            cell.classList.remove("error");
+        });
+
+        const invalidCells: string[] = [];
+        const data = this.editedScoreItems;
+        data.forEach(item => {
+            const row = item.order + 1;
+            if (item.name === "") {
+                invalidCells.push("B" + row);
+            }
+            // Check if maximum is a positive number < 1000
+            // we use a regex instead of parseFloat because parseFloat is too lenient
+            if (! /^\d{1,3}(.\d*)?$/.test(item.maximum) || parseFloat(item.maximum) <= 0) {
+                invalidCells.push("D" + row);
+            }
+        });
+        invalidCells.forEach(cell => {
+            this.table.getCell(cell).classList.add("error");
+        });
+        this.hasErrors = invalidCells.length > 0;
+        return !this.hasErrors;
+    }
+
+    confirmWarnings(): boolean {
+        const old = this.scoreItems;
+        const edited = this.editedScoreItems;
+        const removed = old.some(item => !edited.some(e => e.id === item.id));
+        const maxEdited = old.some(item => edited.some(e => e.id === item.id && e.maximum !== item.maximum));
+
+        let warnings = "";
+        if (removed) {
+            warnings += i18n.t("js.score_items.deleted_warning") + "\n";
+        }
+        if (maxEdited) {
+            warnings += i18n.t("js.score_items.modified_warning") + "\n";
+        }
+
+        return warnings === "" || confirm(warnings);
+    }
+
+    async save(): Promise<void> {
+        if (!this.validate()) {
+            return;
+        }
+
+        if (!this.confirmWarnings()) {
+            return;
+        }
+
+        const response = await fetch(this.route, {
+            method: "PATCH",
+            headers: {
+                "Content-Type": "application/json"
+            },
+            body: JSON.stringify({
+                score_items: this.editedScoreItems
+            })
+        });
+        if (response.ok) {
+            const js = await response.text();
+            eval(js);
+        }
+    }
+
+    cancel(): void {
+        if (this.table) {
+            this.table.setData(this.data);
+        }
+        this.dispatchEvent(new Event("cancel"));
+    }
+
+
+    render(): TemplateResult {
+        return html`
+            ${this.hasErrors ? html`<div class="alert alert-danger">${i18n.t("js.score_items.validation_warning")}</div>` : ""}
+            <div style="width: 100%" ${ref(this.tableRef)} contenteditable="true"></div>
+            <div class="d-flex justify-content-end">
+                <button @click=${this.cancel} class="btn btn-text me-1">
+                    ${i18n.t("js.score_items.cancel")}
+                </button>
+                <button @click=${this.save} class="btn btn-filled">
+                    ${i18n.t("js.score_items.save")}
+                </button>
+            </div>
+        `;
+    }
+}

app/assets/javascripts/i18n/translations.json

@@ -363,6 +363,27 @@
       "score_item": {
         "error": "Error while updating"
       },
+      "score_items": {
+        "cancel": "Cancel",
+        "deleted_warning": "You have deleted one or more score items. This will also delete all scores for these items.",
+        "description": "Description",
+        "description_help": "A description is optional. Markdown formatting can be used. This is visible to the students.",
+        "jspreadsheet": {
+          "copy": "Copy...",
+          "deleteSelectedRows": "Delete selected rows",
+          "insertNewRowAfter": "Insert new row after",
+          "insertNewRowBefore": "Insert new row before",
+          "paste": "Paste..."
+        },
+        "maximum": "Maximum",
+        "maximum_help": "The maximum grade for this score item. The grade should be between 0 and 1000, and works in increments of 0.25.",
+        "modified_warning": "You have changed the maximum score of one or more score items. This will mark all completed evaluations with this score item as uncompleted.",
+        "name": "Name",
+        "save": "Save",
+        "validation_warning": "All score items must have a name and a maximum score, and the maximum score must be between 0 and 1000.",
+        "visible": "Visible",
+        "visible_help": "Make the score item visible to students once the evaluation is released."
+      },
       "sign_in_search_bar": {
         "institution_search": "Type to search for your institution",
         "log_in": "Sign in"
@@ -868,6 +889,27 @@
       "score_item": {
         "error": "Fout bij bijwerken"
       },
+      "score_items": {
+        "cancel": "Annuleren",
+        "deleted_warning": "Je hebt een of meerdere scoreonderdelen verwijderd. Dit zal ook de bijhorende scores van de studenten verwijderen.",
+        "description": "Beschrijving",
+        "description_help": "Een beschrijving is optioneel en kan in Markdown geschreven worden. Dit is zichtbaar voor de studenten.",
+        "jspreadsheet": {
+          "copy": "Kopiëer...",
+          "deleteSelectedRows": "Verwijder geselecteerde rijen",
+          "insertNewRowAfter": "Voeg nieuwe rij toe na deze",
+          "insertNewRowBefore": "Voeg nieuwe rij toe voor deze",
+          "paste": "Plak..."
+        },
+        "maximum": "Maximum",
+        "maximum_help": "De maximumscore voor dit scoreonderdeel. Dit moet een getal zijn tussen 0 en 1000 en gaat in stappen van 0.25.",
+        "modified_warning": "Je hebt de maximumscore van een of meerdere scoreonderdelen aangepast. Alle afgewerkte evaluaties met dit scoreonderdeel zullen terug als onafgewerkt gemarkeerd worden.",
+        "name": "Naam",
+        "save": "Opslaan",
+        "validation_warning": "Alle scoreonderdelen moeten een naam en een maximumscore hebben. De maximumscore moet een getal zijn tussen 0 en 1000.",
+        "visible": "Zichtbaar",
+        "visible_help": "Maak het scoreonderdeel zichtbaar voor studenten eens de evaluatie vrijgegeven is."
+      },
       "sign_in_search_bar": {
         "institution_search": "Typ om jouw school te vinden",
         "log_in": "Aanmelden"

app/assets/javascripts/score_item.ts

@@ -1,5 +1,6 @@
 import { fetch } from "utilities";
 import { i18n } from "i18n/i18n";
+import { ScoreItemInputTable } from "components/input_table";
 
 function commonCheckboxInit(
     element: HTMLElement,
@@ -44,18 +45,28 @@
     });
 }
 
-function initItemVisibilityCheckboxes(element: HTMLElement): void {
-    commonCheckboxInit(element, ".visibility-checkbox", checked => {
-        return {
-
-            score_item: {
-                visible: checked
-            }
-        };
-    });
-}
-
 export function initVisibilityCheckboxes(element: HTMLElement): void {
     initTotalVisibilityCheckboxes(element);
-    initItemVisibilityCheckboxes(element);
+}
+
+export function initEditButton(element: HTMLElement): void {
+    const editBtn = element.querySelector(".edit-btn") as HTMLAnchorElement;
+    const table = element.querySelector(".score-items-table") as HTMLTableElement;
+    const form = element.querySelector("d-score-item-input-table") as ScoreItemInputTable;
+
+    const activateEditMode = (e: MouseEvent): void => {
+        e.preventDefault();
+        table.classList.add("d-none");
+        editBtn.classList.add("d-none");
+        form.classList.remove("d-none");
+    };
+
+    editBtn.addEventListener("click", activateEditMode);
+    table.addEventListener("click", activateEditMode);
+
+    form.addEventListener("cancel", () => {
+        table.classList.remove("d-none");
+        editBtn.classList.remove("d-none");
+        form.classList.add("d-none");
+    });
 }

app/assets/javascripts/utilities.ts

@@ -269,5 +269,5 @@ export {
     ready,
     getParentByClassName,
     setHTMLExecuteScripts,
-    replaceHTMLExecuteScripts,
+    replaceHTMLExecuteScripts
 };

app/assets/stylesheets/base.css.scss

@@ -64,11 +64,16 @@
 @import "../../../node_modules/bootstrap/scss/offcanvas";
 @import "../../../node_modules/bootstrap/scss/utilities/api";
 
+// jspreadsheet styles
+@import "../../../node_modules/jspreadsheet-ce/dist/jspreadsheet";
+@import "../../../node_modules/jsuites/dist/jsuites";
+
 :root {
   --scrollbar-width: 20px;
 }
 
 // 5. Add additional custom code here
+@import "theme/jspreadsheet.css.scss";
 @import "bootstrap_style_overrides.css.scss";
 @import "libraries.css.scss";
 @import "material_icons.css.scss";