terrier-engine 4.4.0 → 4.4.3

package/data-dive/dives/group-editor.ts

@@ -0,0 +1,139 @@
+import {ModalPart} from "../../terrier/modals"
+import TerrierPart from "../../terrier/parts/terrier-part"
+import {DdDiveGroup, UnpersistedDdDiveGroup} from "../gen/models"
+import Db from "../dd-db"
+import {PartTag} from "tuff-core/parts"
+import {messages} from "tuff-core"
+import {DbErrors} from "../../terrier/db-client"
+import DdSession from "../dd-session"
+import Nav from "tuff-core/nav"
+import {routes} from "../dd-routes"
+import {TerrierFormFields} from "../../terrier/forms"
+
+class GroupForm extends TerrierPart<{ group: UnpersistedDdDiveGroup }> {
+
+    fields!: TerrierFormFields<UnpersistedDdDiveGroup>
+
+    async init() {
+        this.fields = new TerrierFormFields(this, this.state.group)
+    }
+
+    setErrors(errors: DbErrors<UnpersistedDdDiveGroup>) {
+        this.fields.errors = errors
+        this.dirty()
+    }
+
+    get parentClasses(): Array<string> {
+        return ['tt-form', 'tt-flex', 'column', 'gap', 'padded']
+    }
+
+    render(parent: PartTag): any {
+        this.fields.renderErrorBubble(parent)
+        parent.div('.tt-flex.collapsible.gap', row => {
+            row.div('.stretch', col => {
+                col.label().text("Name")
+                this.fields.textInput(col, 'name')
+                // col.label().text("Types")
+                // col.div('.tt-flex.gap', typeRow => {
+                //     for (const type of DdDiveEnumFields.visibility)
+                // })
+            })
+            row.div('.stretch', col => {
+                col.label().text("Description")
+                this.fields.textArea(col, 'description_raw')
+            })
+        })
+    }
+
+    async serialize(): Promise<UnpersistedDdDiveGroup> {
+        return this.fields.serialize()
+    }
+
+}
+
+
+export type GroupModalState = {
+    session: DdSession
+    group: UnpersistedDdDiveGroup
+    callback: (group: DdDiveGroup) => any
+}
+
+export class GroupEditorModal extends ModalPart<GroupModalState> {
+
+    form!: GroupForm
+    saveKey = messages.untypedKey()
+    deleteKey = messages.untypedKey()
+
+    async init() {
+        const group = this.state.group
+        this.form = this.makePart(GroupForm, {group})
+
+        this.setTitle(group.id?.length ? "Edit Group" : "New Group")
+        this.setIcon('glyp-grouped')
+
+        this.addAction({
+            title: 'Save',
+            icon: 'glyp-checkmark',
+            click: {key: this.saveKey}
+        })
+
+        if (group.id?.length && this.state.session.isSuper) {
+            this.addAction({
+                title: 'Delete',
+                icon: 'glyp-delete',
+                classes: ['alert'],
+                click: {key: this.deleteKey}
+            }, 'secondary')
+        }
+
+        this.onClick(this.saveKey, _ => {
+            this.save()
+        })
+
+
+        this.onClick(this.deleteKey, async _ => {
+            this.app.confirm({
+                title: 'Delete this group?',
+                body: "Are you sure you want to delete this group?",
+                icon: 'glyp-delete'
+            }, () => {
+                this.delete()
+            })
+        })
+    }
+
+    renderContent(parent: PartTag): void {
+        parent.part(this.form)
+    }
+
+    async save() {
+        this.startLoading()
+        const unpersistedGroup = await this.form.serialize()
+        const res = await Db().upsert('dd_dive_group', unpersistedGroup)
+        this.stopLoading()
+        if (res.status == 'success') {
+            this.state.callback(res.record)
+            this.successToast(`Saved group ${res.record?.name}`)
+            this.pop()
+        }
+        else {
+            this.alertToast(`Error saving group: ${res.message}`)
+            this.form.setErrors(res.errors)
+        }
+    }
+
+    async delete() {
+        const group = {...this.state.group}
+        group._state = 2
+        const res = await Db().upsert('dd_dive_group', group)
+        if (res.status == 'success') {
+            this.pop()
+            this.successToast(`Deleted group ${group.name}`)
+            Nav.visit(routes.list.path({}))
+        } else {
+            this.form.setErrors(res.errors)
+        }
+    }
+
+
+}

package/data-dive/gen/models.ts

@@ -0,0 +1,192 @@
+// This file was automatically generated, DO NOT EDIT IT MANUALLY!
+
+import { Query } from "../queries/queries"
+
+import { DdUser } from "../dd-user"
+
+import { FilterInput } from "../queries/filters"
+
+import { OptionalProps } from "tuff-core/types"
+
+import { Attachment } from "../../terrier/attachments"
+
+export type DdDive = {
+    id: string
+    created_at: string
+    updated_at: string
+    _state: number
+    created_by_id?: string
+    created_by_name: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    owner_id?: string
+    dd_dive_group_id?: string
+    name: string
+    description_raw?: string
+    description_html?: string
+    visibility: "public" | "private"
+    sort_order?: number
+    query_data?: { queries: Query[] }
+    dive_types: string[]
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dive_group?: DdDiveGroup
+    dd_dive_runs?: DdDiveRun[]
+    owner?: DdUser
+}
+
+export type UnpersistedDdDive = {
+    id?: string
+    created_at?: string
+    updated_at?: string
+    _state?: number
+    created_by_id?: string
+    created_by_name?: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    owner_id?: string
+    dd_dive_group_id?: string
+    name: string
+    description_raw?: string
+    description_html?: string
+    visibility: "public" | "private"
+    sort_order?: number
+    query_data?: { queries: Query[] }
+    dive_types: string[]
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dive_group?: DdDiveGroup
+    dd_dive_runs?: OptionalProps<UnpersistedDdDiveRun, "dd_dive_id">[]
+    owner?: DdUser
+}
+
+export const DdDiveEnumFields = {
+    visibility: ["public", "private"] as const,
+}
+
+export type DdDiveGroup = {
+    id: string
+    created_at: string
+    updated_at: string
+    _state: number
+    created_by_id?: string
+    created_by_name: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    name: string
+    icon?: string
+    description_raw?: string
+    description_html?: string
+    sort_order?: number
+    group_types: string[]
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dives?: DdDive[]
+}
+
+export type UnpersistedDdDiveGroup = {
+    id?: string
+    created_at?: string
+    updated_at?: string
+    _state?: number
+    created_by_id?: string
+    created_by_name?: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    name: string
+    icon?: string
+    description_raw?: string
+    description_html?: string
+    sort_order?: number
+    group_types: string[]
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dives?: OptionalProps<UnpersistedDdDive, "dd_dive_group_id">[]
+}
+
+export type DdDiveRun = {
+    id: string
+    created_at: string
+    updated_at: string
+    _state: number
+    created_by_id?: string
+    created_by_name: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    dd_dive_id?: string
+    input_data?: { queries: Query[]; filters: FilterInput[] }
+    output_data?: object
+    output_file_data?: Attachment | { path: string }
+    status: "initial" | "running" | "success" | "error"
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dive?: DdDive
+    output_file?: File
+}
+
+export type UnpersistedDdDiveRun = {
+    id?: string
+    created_at?: string
+    updated_at?: string
+    _state?: number
+    created_by_id?: string
+    created_by_name?: string
+    extern_id?: string
+    updated_by_id?: string
+    updated_by_name?: string
+    dd_dive_id?: string
+    input_data?: { queries: Query[]; filters: FilterInput[] }
+    output_data?: object
+    output_file_data?: Attachment | { path: string }
+    status: "initial" | "running" | "success" | "error"
+    created_by?: DdUser
+    updated_by?: DdUser
+    dd_dive?: DdDive
+    output_file?: File
+}
+
+export const DdDiveRunEnumFields = {
+    status: ["initial", "running", "success", "error"] as const,
+}
+
+/**
+ * Map model names to their types.
+ */
+export type PersistedModelTypeMap = {
+    dd_dive: DdDive
+    dd_dive_group: DdDiveGroup
+    dd_dive_run: DdDiveRun
+}
+
+/**
+ * Map model names to their unpersisted types.
+ */
+export type UnpersistedModelTypeMap = {
+    dd_dive: UnpersistedDdDive
+    dd_dive_group: UnpersistedDdDiveGroup
+    dd_dive_run: UnpersistedDdDiveRun
+}
+
+/**
+ * Map model names to their association names.
+ */
+export type ModelIncludesMap = {
+    dd_dive: "created_by" | "dd_dive_group" | "dd_dive_runs" | "owner" | "updated_by"
+    dd_dive_group: "created_by" | "dd_dives" | "updated_by"
+    dd_dive_run: "created_by" | "dd_dive" | "updated_by"
+}
+
+/**
+ * Map "sluggable" model names to their types
+ */
+export type SluggableModelTypeMap = {}
+
+/**
+ * A type consisting of all possible model names.
+ */
+export type ModelName = keyof PersistedModelTypeMap & keyof UnpersistedModelTypeMap

package/data-dive/queries/columns.ts

@@ -0,0 +1,355 @@
+import {PartTag} from "tuff-core/parts"
+import {ColumnDef, ModelDef, SchemaDef} from "../../terrier/schema"
+import {TableRef, TableView} from "./tables"
+import {Logger} from "tuff-core/logging"
+import {FormFields, SelectOptions} from "tuff-core/forms"
+import Forms from "../../terrier/forms"
+import {arrays, messages} from "tuff-core"
+import Objects from "tuff-core/objects"
+import {ModalPart} from "../../terrier/modals";
+import TerrierFormPart from "../../terrier/parts/terrier-form-part"
+import {Dropdown} from "../../terrier/dropdowns"
+
+const log = new Logger("Columns")
+
+////////////////////////////////////////////////////////////////////////////////
+// Types
+////////////////////////////////////////////////////////////////////////////////
+
+/**
+ * Possible functions used to aggregate a column.
+ */
+const AggFunctions = ['count', 'min', 'max'] as const
+
+export type AggFunction = typeof AggFunctions[number]
+
+
+/**
+ * Possible functions used to manipulate a date column.
+ */
+const DateFunctions = ['year', 'month', 'day'] as const
+
+export type DateFunction = typeof DateFunctions[number]
+
+export type Function = AggFunction | DateFunction
+
+/**
+ * @param fun a function name
+ * @return the type of function
+ */
+function functionType(fun: Function): 'aggregate' | 'time' | undefined {
+    if (AggFunctions.includes(fun as AggFunction)) {
+        return 'aggregate'
+    }
+    else if (DateFunctions.includes(fun as DateFunction)) {
+        return 'time'
+    }
+    return undefined
+}
+
+/**
+ * A reference to a single column, possibly grouped or with a function applied
+ */
+export type ColumnRef = {
+    name: string
+    alias?: string
+    grouped?: boolean
+    function?: AggFunction | DateFunction
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Rendering
+////////////////////////////////////////////////////////////////////////////////
+
+function render(parent: PartTag, col: ColumnRef) {
+    if (col.grouped) {
+        parent.i('.glyp-grouped')
+    }
+    if (col.function?.length) {
+        parent.i(`.glyp-function`)
+        parent.div('.function').text(`${col.function}(<strong>${col.name}</strong>)`)
+    } else {
+        parent.div('.name').text(col.name)
+    }
+    if (col.alias?.length) {
+        parent.div('.as').text('as')
+        parent.div('.alias').text(col.alias)
+    }
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Editor
+////////////////////////////////////////////////////////////////////////////////
+
+export type ColumnsEditorState = {
+    schema: SchemaDef
+    tableView: TableView<TableRef>
+}
+
+const saveKey = messages.untypedKey()
+const addKey = messages.untypedKey()
+const removeKey = messages.typedKey<{id: string}>()
+
+/**
+ * A modal that lets the user edit the columns being referenced for a particular table.
+ */
+export class ColumnsEditorModal extends ModalPart<ColumnsEditorState> {
+
+    modelDef!: ModelDef
+    table!: TableRef
+    columnStates: ColumnState[] = []
+    columnCount = 0
+
+    tableFields!: FormFields<TableRef>
+
+    updateColumnEditors() {
+        this.assignCollection('columns', ColumnEditor, this.columnStates)
+    }
+
+    addState(col: ColumnRef) {
+        this.columnCount += 1
+        this.columnStates.push({schema: this.state.schema, columnsEditor: this, id: `column-${this.columnCount}`, ...col})
+    }
+
+
+    async init () {
+        this.table = this.state.tableView.table
+        this.modelDef = this.state.tableView.modelDef
+
+        this.tableFields = new FormFields(this, {...this.table})
+
+        // initialize the columns states
+        const columns: ColumnRef[] = this.table.columns || []
+        for (const col of columns) {
+            this.addState(col)
+        }
+        this.updateColumnEditors()
+
+        this.setTitle(`Columns for ${this.state.tableView.displayName}`)
+        this.setIcon('glyp-columns')
+
+        this.addAction({
+            title: 'Apply',
+            icon: 'glyp-checkmark',
+            click: {key: saveKey}
+        }, 'primary')
+
+        this.addAction({
+            title: 'Add Columns',
+            icon: 'glyp-plus',
+            click: {key: addKey}
+        }, 'secondary')
+
+        this.onClick(saveKey, _ => {
+            this.save()
+        })
+
+        this.onClick(removeKey, m => {
+            this.removeColumn(m.data.id)
+        })
+
+        this.onClick(addKey, m => {
+            const onSelected = (columns: string[]) => {
+                log.info(`Adding ${columns.length} columns`, columns)
+                for (const col of columns) {
+                    const colDef = this.modelDef.columns[col]
+                    if (colDef) {
+                        this.addState({name: colDef.name})
+                    }
+                }
+                this.updateColumnEditors()
+            }
+            this.toggleDropdown(SelectColumnsDropdown, {modelDef: this.modelDef, callback: onSelected}, m.event.target)
+        })
+    }
+
+    renderContent(parent: PartTag): void {
+        parent.div('.tt-flex.tt-form.padded.gap.justify-end.align-center', row => {
+            row.div('.tt-compound-field', field => {
+                field.label().text("Prefix:")
+                this.tableFields.textInput(field, 'prefix')
+            })
+            row.div('.stretch').text("All columns will be prefixed with this")
+        })
+        parent.div('.dd-columns-editor-table', table => {
+            table.div('.dd-editor-header', header => {
+                header.div('.name').label({text: "Name"})
+                header.div('.alias').label({text: "Alias"})
+                header.div('.function').label({text: "Function"})
+                header.div('.group-by').label({text: "Group By?"})
+            })
+            this.renderCollection(table, 'columns')
+                .class('dd-editor-row-container')
+        })
+    }
+
+    removeColumn(id: string) {
+        const col = arrays.find(this.columnStates, c => c.id == id)
+        if (col) {
+            this.columnStates = arrays.without(this.columnStates, col)
+            this.updateColumnEditors()
+        }
+    }
+
+    async save() {
+        const columns = this.columnStates.map(state => {
+            return Objects.omit(state, 'schema', 'columnsEditor', 'id') as ColumnRef
+        })
+        const tableData = await this.tableFields.serialize()
+        this.state.tableView.updateColumns(columns, tableData.prefix)
+        this.pop()
+    }
+
+}
+
+type ColumnState = ColumnRef & {
+    schema: SchemaDef
+    columnsEditor: ColumnsEditorModal
+    id: string
+}
+
+/**
+ * An editor row for an individual column.
+ */
+class ColumnEditor extends TerrierFormPart<ColumnState> {
+
+    schema!: SchemaDef
+    modelDef!: ModelDef
+    columnDef!: ColumnDef
+
+    functionOptions!: SelectOptions
+
+    async init() {
+        this.schema = this.state.schema
+        this.modelDef = this.state.columnsEditor.modelDef
+        this.columnDef = this.modelDef.columns[this.state.name]
+        log.info(`Column ${this.state.name} definition:`, this.columnDef)
+
+        let funcs = Array.from<string>(AggFunctions)
+        if (this.columnDef.type == 'date' || this.columnDef.type.includes('time')) {
+            funcs = funcs.concat(Array.from(DateFunctions))
+        }
+        this.functionOptions = Forms.titleizeOptions(funcs, '')
+    }
+
+    get parentClasses(): Array<string> {
+        return super.parentClasses.concat(['dd-editor-row'])
+    }
+
+    render(parent: PartTag) {
+        parent.div('.name', col => {
+            col.div('.tt-readonly-field', {text: this.state.name})
+        })
+        parent.div('.alias', col => {
+            this.textInput(col, "alias", {placeholder: "Alias"})
+        })
+        parent.div('.function', col => {
+            this.select(col, "function", this.functionOptions)
+        })
+        parent.div('.group-by', col => {
+            this.checkbox(col, "grouped")
+        })
+        parent.div('.actions', actions => {
+            actions.a(a => {
+                a.i('.glyp-close')
+            }).emitClick(removeKey, {id: this.state.id})
+        })
+    }
+    
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Add Column Dropdown
+////////////////////////////////////////////////////////////////////////////////
+
+const checkAllKey = messages.untypedKey()
+const applySelectionKey = messages.untypedKey()
+const checkChangedKey = messages.typedKey<{column: string}>()
+
+type SelectColumnsCallback = (columns: string[]) => any
+
+/**
+ * Shows a dropdown that allows the user to select one or more columns from the given model.
+ */
+class SelectColumnsDropdown extends Dropdown<{modelDef: ModelDef, callback: SelectColumnsCallback}> {
+
+    checked: Set<string> = new Set()
+    columns!: string[]
+
+    async init() {
+        this.columns = Object.keys(this.state.modelDef.columns).sort()
+
+        this.onClick(checkAllKey, _ => {
+            // toggle them all being checked
+            const trues = Object.values(this.checked).filter(b => b)
+            if (trues.length > this.columns.length / 2) {
+                this.checked = new Set()
+            }
+            else {
+                for (const c of this.columns) {
+                    this.checked.add(c)
+                }
+            }
+            this.dirty()
+        })
+
+        this.onClick(applySelectionKey, _ => {
+            this.state.callback(Array.from(this.checked))
+            this.clear()
+        })
+
+        this.onChange(checkChangedKey, m => {
+            const col = m.data.column
+            const checked = (m.event.target as HTMLInputElement).checked
+            log.info(`Column '${col}' checkbox changed to`, checked)
+            if (checked) {
+                this.checked.add(col)
+            }
+            else {
+                this.checked.delete(col)
+            }
+        })
+    }
+
+
+    get parentClasses(): Array<string> {
+        return super.parentClasses.concat(['dd-select-columns-dropdown']);
+    }
+
+    renderContent(parent: PartTag) {
+        parent.a(a => {
+            a.i('.glyp-check_all')
+            a.span({text: "Toggle All"})
+        }).emitClick(checkAllKey)
+
+        for (const col of this.columns) {
+            parent.label(label => {
+                label.input({type: 'checkbox', checked: this.checked.has(col)})
+                    .emitChange(checkChangedKey, {column: col})
+                label.div().text(col)
+            })
+        }
+
+        parent.a('.add', a => {
+            a.i('.glyp-checkmark')
+            a.span({text: "Add Selected"})
+        }).emitClick(applySelectionKey)
+    }
+
+}
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Export
+////////////////////////////////////////////////////////////////////////////////
+
+const Columns = {
+    render,
+    functionType
+}
+
+export default Columns