rollups working correctly

Author: RafaelGB

src/automations/FormulaGenerator.ts

@@ -1,7 +1,9 @@
 import { FormulaFunctions } from "automations/formula_functions/FormulaFunctions";
 import { IGenerateObject } from "automations/IGenerateObject";
 import { LocalSettings } from "cdm/SettingsModel";
+import { Link } from "obsidian-dataview";
 import { DataviewService } from "services/DataviewService";
+import Rollup from "automations/Rollup";
 export class FormulaGenerator implements IGenerateObject {
     public js_functions: FormulaFunctions;
 
@@ -17,7 +19,8 @@ export class FormulaGenerator implements IGenerateObject {
         const final_object: Record<string, any> = {};
         Object.assign(final_object, {
             js: await this.generate_js_functions(),
-            dataview: DataviewService.getDataviewAPI()
+            dataview: DataviewService.getDataviewAPI(),
+            rollup: (relation: Link[], action?: string, key?: string) => new Rollup(relation, action, key)
         }
         );
         return final_object;

src/automations/Rollup.ts

@@ -1,32 +1,54 @@
-import { ROLLUP_ACTIONS } from "helpers/Constants";
+import { DEFAULT_SETTINGS, InputType, ROLLUP_ACTIONS } from "helpers/Constants";
 import { Link, Literal } from "obsidian-dataview";
 import { DataviewService } from "services/DataviewService";
 import { LOGGER } from "services/Logger";
+import { ParseService } from "services/ParseService";
 
 class Rollup {
     private pages: Record<string, Literal>[];
     private action: string;
     private key: string;
 
-    constructor(relation: Link[], action: string, key: string) {
-        const consultedLinks = relation.map((link) =>
+    static generatePages(relation: Link[]): Record<string, Literal>[] {
+        return relation.map((link) =>
             DataviewService.getDataviewAPI().page(link.path)
         );
+    }
+
+    constructor(relation: Link[], action?: string, key?: string) {
+        const consultedLinks = Rollup.generatePages(relation);
         this.pages = consultedLinks;
         this.action = action;
         this.key = key;
     }
+
     public dispatch(): string {
+        let result = "";
         switch (this.action) {
             case ROLLUP_ACTIONS.SUM:
-                return this.sum();
+                result = this.sum();
+                break;
+            case ROLLUP_ACTIONS.COUNT_ALL:
+                result = this.countAll();
+                break;
+            case ROLLUP_ACTIONS.ORIGINAL_VALUE:
+                result = this.originalValue();
+                break;
             default:
                 // No valid action found
                 LOGGER.warn(`No valid action found for rollup: ${this.action}`);
-                return "";
         }
+        return result;
+    }
+
+    public getPages(): Record<string, Literal>[] {
+        return this.pages;
     }
 
+    /**
+     * Iters over the pages and sums the values of the key
+     * @returns 
+     */
     private sum(): string {
         // Check if key is not truthy, return empty string
         if (!this.key) {
@@ -41,6 +63,25 @@ class Rollup {
         return sum.toString();
     }
 
+    /**
+     * Obtains the number of pages of the relation with the key informed
+     * @returns 
+     */
+    private countAll(): string {
+        return this.pages.filter((page) => page[this.key]).length.toString();
+    }
+
+    /**
+     * Returns the original value map of the pages with the key informed
+     * @returns 
+     */
+    private originalValue(): string {
+        // TODO use local settings of the table instead of default settings
+        return this.pages
+            .filter((page) => page[this.key])
+            .map((page) => ParseService.parseLiteral(page[this.key], InputType.MARKDOWN, DEFAULT_SETTINGS.local_settings)).join(", ");
+    }
+
 }
 
 export default Rollup;

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

@@ -8,32 +8,41 @@ export class RollupActionHandler extends AbstractHandlerClass<ColumnSettingsHand
     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
+        const { config } = column
+        // Check if there is a relation associated
+        if (config.asociated_relation_id) {
+            // select rollup action
+            const rollup_action_options: Record<string, string> = {};
+            Object.values(ROLLUP_ACTIONS).forEach((action) => {
+                rollup_action_options[action] = action;
             });
-            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);
-            });
+            const rollup_action_promise = async (value: string): Promise<void> => {
+                if (config.rollup_action !== value) {
+                    config.rollup_action = value;
+                    // Persist on disk
+                    await view.diskConfig.updateColumnConfig(column.id, {
+                        rollup_action: value
+                    });
+                    columnSettingsManager.modal.enableReset = true;
+                    // re-render column settings
+                    columnSettingsManager.reset(columnHandlerResponse);
+                }
+            };
+
+            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(config.rollup_action)
+                        .onChange(rollup_action_promise);
+                });
+        }
         return this.goNext(columnHandlerResponse);
     }
 }

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

@@ -18,13 +18,18 @@ export class RollupAsociatedRelationHandler extends AbstractHandlerClass<ColumnS
                 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;
+            if (config.asociated_relation_id !== value) {
+                config.asociated_relation_id = value;
+                // Persist on disk
+                await view.diskConfig.updateColumnConfig(column.id, {
+                    rollup_relation: value
+                });
+                columnSettingsManager.modal.enableReset = true;
+                // re-render column settings
+                columnSettingsManager.reset(columnHandlerResponse);
+            }
         };
+
         new Setting(containerEl)
             .setName(this.settingTitle)
             .setDesc('Select from the existing columns to rollup')
@@ -34,7 +39,7 @@ export class RollupAsociatedRelationHandler extends AbstractHandlerClass<ColumnS
                     avaliableRelations
                 );
                 cb.setPlaceholder("Search Relation...")
-                    .setValue(column.config.asociated_relation_id)
+                    .setValue(config.asociated_relation_id)
                     .onChange(relation_selector_promise);
             });
         return this.goNext(columnHandlerResponse);

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

@@ -10,6 +10,7 @@ export class RollupKeyHandler extends AbstractHandlerClass<ColumnSettingsHandler
         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> => {

src/helpers/Constants.ts

@@ -442,5 +442,7 @@ export const DB_ICONS = Object.freeze({
 });
 
 export const ROLLUP_ACTIONS = Object.freeze({
-  SUM: 'sum',
+  SUM: 'Summatory',
+  COUNT_ALL: 'Count All',
+  ORIGINAL_VALUE: 'Original Value',
 });