rollup better manage

Author: RafaelGB

src/components/modals/columnSettings/ColumnSections.ts

@@ -11,11 +11,15 @@ import { AlignmentSelectorHandler } from "components/modals/columnSettings/handl
 import { ToggleWrapContentHandler } from "components/modals/columnSettings/handlers/styles/ToggleWrapContentHandler";
 import { ColumnIdInputHandler } from "components/modals/columnSettings/handlers/ColumnIdInputHandler";
 import { DatabaseSelectorHandler } from "components/modals/columnSettings/handlers/dropdowns/DatabaseSelectorHandler";
-import { RollupInputHandler } from "components/modals/columnSettings/handlers/automations/RollupInputHandler";
+import { RollupAsociatedRelationHandler } from "components/modals/columnSettings/handlers/rollups/RollupAsociatedRelationHandler";
+import { RollupActionHandler } from "components/modals/columnSettings/handlers/rollups/RollupActionHandler";
+import { RollupKeyHandler } from "components/modals/columnSettings/handlers/rollups/RollupKeyHandler";
+import { RollupPersistToggleHandler } from "components/modals/columnSettings/handlers/rollups/RollupPersistToggleHandler";
 import { InputType } from "helpers/Constants";
 import { AbstractChain } from "patterns/AbstractFactoryChain";
 import { AbstractHandler } from "patterns/AbstractHandler";
 
+
 class StyleSetttingsSection extends AbstractChain<ColumnSettingsHandlerResponse> {
     private input: string = InputType.TEXT;
     protected runBefore(columnHandlerResponse: ColumnSettingsHandlerResponse): ColumnSettingsHandlerResponse {
@@ -116,7 +120,10 @@ class ParticularSetttingsSection extends AbstractChain<ColumnSettingsHandlerResp
                 particularHandlers.push(new DatabaseSelectorHandler());
                 break;
             case InputType.ROLLUP:
-                particularHandlers.push(new RollupInputHandler());
+                particularHandlers.push(new RollupAsociatedRelationHandler());
+                particularHandlers.push(new RollupActionHandler())
+                particularHandlers.push(new RollupKeyHandler());
+                particularHandlers.push(new RollupPersistToggleHandler());
                 break;
             default:
                 break;

src/components/modals/columnSettings/handlers/automations/RollupInputHandler.ts

@@ -0,0 +1,39 @@
+import { ColumnSettingsHandlerResponse } from "cdm/ModalsModel";
+import { AbstractHandlerClass } from "patterns/AbstractHandler";
+import { Setting } from "obsidian";
+import { StringSuggest } from "settings/suggesters/StringSuggester";
+import { ROLLUP_ACTIONS } from "helpers/Constants";
+export class RollupActionHandler extends AbstractHandlerClass<ColumnSettingsHandlerResponse>  {
+    settingTitle: string = 'Select action';
+    handle(columnHandlerResponse: ColumnSettingsHandlerResponse): ColumnSettingsHandlerResponse {
+        const { column, containerEl, columnSettingsManager } = columnHandlerResponse;
+        const { view } = columnSettingsManager.modal;
+        // select rollup action
+        const rollup_action_options: Record<string, string> = {};
+        Object.values(ROLLUP_ACTIONS).forEach((action) => {
+            rollup_action_options[action] = action;
+        });
+
+        const rollup_action_promise = async (value: string): Promise<void> => {
+            // Persist on disk
+            await view.diskConfig.updateColumnConfig(column.id, {
+                rollup_action: value
+            });
+            columnSettingsManager.modal.enableReset = true;
+        };
+
+        new Setting(containerEl)
+            .setName(this.settingTitle)
+            .setDesc('Select the action to perform on the rollup')
+            .addSearch((cb) => {
+                new StringSuggest(
+                    cb.inputEl,
+                    rollup_action_options
+                );
+                cb.setPlaceholder("Select action...")
+                    .setValue(column.config.rollup_action)
+                    .onChange(rollup_action_promise);
+            });
+        return this.goNext(columnHandlerResponse);
+    }
+}

src/components/modals/columnSettings/handlers/rollups/RollupActionHandler.ts

@@ -0,0 +1,42 @@
+import { ColumnSettingsHandlerResponse } from "cdm/ModalsModel";
+import { AbstractHandlerClass } from "patterns/AbstractHandler";
+import { Setting } from "obsidian";
+import { StringSuggest } from "settings/suggesters/StringSuggester";
+import { InputType } from "helpers/Constants";
+export class RollupAsociatedRelationHandler extends AbstractHandlerClass<ColumnSettingsHandlerResponse>  {
+    settingTitle: string = 'Select relation column';
+    handle(columnHandlerResponse: ColumnSettingsHandlerResponse): ColumnSettingsHandlerResponse {
+        const { column, containerEl, columnSettingsManager } = columnHandlerResponse;
+        const { view, columnsState } = columnSettingsManager.modal;
+        const { config } = column
+        const allColumns = columnsState.info.getAllColumns();
+        // Select relation from existing columns
+        const avaliableRelations: Record<string, string> = {};
+        allColumns
+            .filter((col) => col.input === InputType.RELATION && col.config.related_note_path)
+            .forEach((col) => {
+                avaliableRelations[col.id] = col.label;
+            });
+        const relation_selector_promise = async (value: string): Promise<void> => {
+            config.asociated_relation_id = value;
+            // Persist value
+            await view.diskConfig.updateColumnConfig(column.id, {
+                rollup_relation: value
+            });
+            columnSettingsManager.modal.enableReset = true;
+        };
+        new Setting(containerEl)
+            .setName(this.settingTitle)
+            .setDesc('Select from the existing columns to rollup')
+            .addSearch((cb) => {
+                new StringSuggest(
+                    cb.inputEl,
+                    avaliableRelations
+                );
+                cb.setPlaceholder("Search Relation...")
+                    .setValue(column.config.asociated_relation_id)
+                    .onChange(relation_selector_promise);
+            });
+        return this.goNext(columnHandlerResponse);
+    }
+}

src/components/modals/columnSettings/handlers/rollups/RollupAsociatedRelationHandler.ts

@@ -0,0 +1,42 @@
+import { ColumnSettingsHandlerResponse } from "cdm/ModalsModel";
+import { AbstractHandlerClass } from "patterns/AbstractHandler";
+import { Setting } from "obsidian";
+import { StringSuggest } from "settings/suggesters/StringSuggester";
+import { recordFieldsFromRelation } from "helpers/RelationHelper";
+export class RollupKeyHandler extends AbstractHandlerClass<ColumnSettingsHandlerResponse>  {
+    settingTitle: string = 'Select property of relation';
+    handle(columnHandlerResponse: ColumnSettingsHandlerResponse): ColumnSettingsHandlerResponse {
+        const { column, containerEl, columnSettingsManager } = columnHandlerResponse;
+        const { view, columnsState, configState } = columnSettingsManager.modal;
+        const { config } = column
+        const allColumns = columnsState.info.getAllColumns();
+        // TODO select key column (if action allows it)
+        const relationColumn = allColumns.find((col) => col.id === config.asociated_relation_id);
+        const rollup_key_promise = async (value: string): Promise<void> => {
+            // Persist on disk
+            await view.diskConfig.updateColumnConfig(column.id, {
+                rollup_key: value
+            });
+            columnSettingsManager.modal.enableReset = true;
+        };
+        recordFieldsFromRelation(
+            relationColumn.config.related_note_path,
+            configState.info.getLocalSettings()
+        ).then((fields) => {
+            new Setting(containerEl)
+                .setName(this.settingTitle)
+                .setDesc('Select the property to rollup from the relation')
+                .addSearch((cb) => {
+                    new StringSuggest(
+                        cb.inputEl,
+                        fields
+                    );
+                    cb.setPlaceholder("Select property...")
+                        .setValue(column.config.rollup_key)
+                        .onChange(rollup_key_promise);
+                });
+            return this.goNext(columnHandlerResponse);
+        });
+        return null;
+    }
+}

src/components/modals/columnSettings/handlers/rollups/RollupKeyHandler.ts

@@ -0,0 +1,27 @@
+import { ColumnSettingsHandlerResponse } from "cdm/ModalsModel";
+import { AbstractHandlerClass } from "patterns/AbstractHandler";
+import { add_toggle } from "settings/SettingsComponents";
+
+export class RollupPersistToggleHandler extends AbstractHandlerClass<ColumnSettingsHandlerResponse>  {
+    settingTitle: string = 'Persist rollup output';
+    handle(columnHandlerResponse: ColumnSettingsHandlerResponse): ColumnSettingsHandlerResponse {
+        const { column, containerEl, columnSettingsManager } = columnHandlerResponse;
+        const { view } = columnSettingsManager.modal;
+        const { config } = column;
+        const persist_rollup_toggle_promise = async (value: boolean): Promise<void> => {
+            // Persist value
+            await view.diskConfig.updateColumnConfig(column.id, {
+                persist_rollup: value
+            });
+            columnSettingsManager.modal.enableReset = true;
+        }
+        add_toggle(
+            containerEl,
+            this.settingTitle,
+            "Enable/disable to persist rollup output on your notes (Only persisted rollups could be searchable and sortable)",
+            config.persist_rollup,
+            persist_rollup_toggle_promise
+        );
+        return this.goNext(columnHandlerResponse);
+    }
+}