- Updated the Obsidian Data View Filter Editor to use security grant for authorized entity types.

Author: joshuahenninger

Rock.Blocks/Example/ControlGallery.cs

@@ -84,6 +84,11 @@ private string GetSecurityGrantToken()
             securityGrant.AddRule( new AssetAndFileManagerSecurityGrantRule( Rock.Security.Authorization.DELETE ) );
             securityGrant.AddRule( new EmailEditorSecurityGrantRule() );
             securityGrant.AddRule( new ConnectionRequestPickerSecurityGrantRule() );
+            securityGrant.AddRule( new DataViewFilterEditorSecurityGrantRule()
+            {
+                // Only allow the gallery's Data View Filter Editor to be used for editing Person data view filters.
+                EntityTypeGuid = Rock.SystemGuid.EntityType.PERSON.AsGuid()
+            } );
 
             return securityGrant.ToToken();
         }

Rock.Enums/Reporting/FilterGroupJoinType.cs

@@ -1,44 +1,43 @@
 <template>
     <GalleryAndResult :importCode="importCode"
                       :exampleCode="exampleCode"
-                      description="Edits a nested DataViewFilter tree using the same filter components that Data Views and Content Channel Views use.">
+                      description="Edits a nested DataViewFilter tree using the same filter components that Data Views use.">
+
+        <NotificationBox alertType="info" heading="Note">
+            This control is for internal use only.
+        </NotificationBox>
 
         <DataViewFilterEditor v-model="value"
-                              :entityTypeGuid="entityTypeGuid?.value" />
+                              :entityTypeGuid="EntityType.Person" />
 
         <template #settings>
-            <div class="row">
-                <div class="col-md-3">
-                    <EntityTypePicker label="For Entity Type"
-                                      v-model="entityTypeGuid"
-                                      enhanceForLongLists
-                                      showBlankItem />
-                </div>
-            </div>
+            <p>This gallery displays the Data View Filters for the <code>Person</code> Entity Type.</p>
         </template>
     </GalleryAndResult>
 </template>
 
 <script setup lang="ts">
-    import { ref, watch } from "vue";
+    import { ref } from "vue";
     import GalleryAndResult from "./common/galleryAndResult.partial.obs";
     import { getSfcControlImportPath } from "./common/utils.partial";
     import DataViewFilterEditor from "@Obsidian/Controls/dataViewFilterEditor.obs";
-    import EntityTypePicker from "@Obsidian/Controls/entityTypePicker.obs";
-    import { createDefaultDataViewFilter } from "@Obsidian/Core/Reporting/dataViewFilterEditor";
+    import NotificationBox from "@Obsidian/Controls/notificationBox.obs";
+    import { FilterExpressionType } from "@Obsidian/Enums/Reporting/filterExpressionType";
     import { EntityType } from "@Obsidian/SystemGuids/entityType";
+    import { newGuid } from "@Obsidian/Utility/guid";
     import { DataViewFilterBag } from "@Obsidian/ViewModels/Reporting/dataViewFilterBag";
-    import type { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
-
-    const defaultEntityTypeGuid = EntityType.Person;
 
-    const entityTypeGuid = ref<ListItemBag | null>({ text: "Person", value: defaultEntityTypeGuid });
-    const value = ref<DataViewFilterBag>(createDefaultDataViewFilter());
+    const value = ref<DataViewFilterBag>({
+        expressionType: FilterExpressionType.GroupAll,
+        guid: newGuid(),
+        childFilters: [
+            {
+                guid: newGuid(),
+                expressionType: FilterExpressionType.Filter
+            }
+        ]
+    });
 
     const importCode = getSfcControlImportPath("dataViewFilterEditor");
-    const exampleCode = `<DataViewFilterEditor v-model="value" :entityTypeGuid="entityTypeGuid" />`;
-
-    watch(entityTypeGuid, () => {
-        value.value = createDefaultDataViewFilter();
-    });
+    const exampleCode = `<DataViewFilterEditor v-model="value" :entityTypeGuid="EntityType.Person" />`;
 </script>

Rock.Enums/Reporting/FilterGroupTruthType.cs

@@ -76,7 +76,7 @@
             </template>
         </template>
 
-        <div class="filter-group-list">
+        <div v-if="childFilters.length" class="filter-group-list">
             <DataViewFilterNode v-for="(child, index) in childFilters"
                                 :key="child.guid"
                                 :modelValue="child"
@@ -87,6 +87,8 @@
                                 @update:modelValue="onUpdateChild(index, $event)"
                                 @delete="removeChild(index)" />
         </div>
+
+        <p v-else class="text-muted">No filters. Click "Add Filter" or "Add Group" to get started.</p>
     </Panel>
 
     <Panel v-else
@@ -214,21 +216,10 @@
     import NotificationBox from "@Obsidian/Controls/notificationBox.obs";
     import Panel from "@Obsidian/Controls/panel.obs";
     import RockButton from "@Obsidian/Controls/rockButton.obs";
-    import {
-        cloneFilterNode,
-        createFilterNode,
-        createGroupNode,
-        getGroupJoinType,
-        getGroupTruthType,
-        isFilterNode,
-        setGroupJoinType,
-        setGroupTruthType
-    } from "@Obsidian/Core/Reporting/dataViewFilterEditor";
     import { FilterExpressionType } from "@Obsidian/Enums/Reporting/filterExpressionType";
-    import { FilterGroupJoinType } from "@Obsidian/Enums/Reporting/filterGroupJoinType";
-    import { FilterGroupTruthType } from "@Obsidian/Enums/Reporting/filterGroupTruthType";
     import { FilterMode } from "@Obsidian/Enums/Reporting/filterMode";
     import type { Guid } from "@Obsidian/Types";
+    import { useSecurityGrantToken } from "@Obsidian/Utility/block";
     import { useHttp } from "@Obsidian/Utility/http";
     import { Enumerable } from "@Obsidian/Utility/linq";
     import { toNumberOrNull } from "@Obsidian/Utility/numberUtils";
@@ -237,12 +228,28 @@
     import { DataViewFilterBag } from "@Obsidian/ViewModels/Reporting/dataViewFilterBag";
     import { DataFilterGetComponentResultsBag } from "@Obsidian/ViewModels/Rest/Controls/dataFilterGetComponentResultsBag";
     import { DataFilterGetSelectionResultsBag } from "@Obsidian/ViewModels/Rest/Controls/dataFilterGetSelectionResultsBag";
+    import { DataFilterExecuteComponentRequestOptionsBag } from "@Obsidian/ViewModels/Rest/Controls/dataFilterExecuteComponentRequestOptionsBag";
     import type { ListItemBag } from "@Obsidian/ViewModels/Utility/listItemBag";
+    import { newGuid } from "@Obsidian/Utility/guid";
 
     defineOptions({
         name: "DataViewFilterNode"
     });
 
+    // #region Types
+
+    enum FilterGroupJoinType {
+        All = 0,
+        Any = 1
+    }
+
+    enum FilterGroupTruthType {
+        True = 0,
+        False = 1
+    }
+
+    // #endregion Types
+
     const props = defineProps({
         modelValue: {
             type: Object as PropType<DataViewFilterBag>,
@@ -272,6 +279,7 @@
     }>();
 
     const http = useHttp();
+    const securityGrantToken = useSecurityGrantToken();
     const node = ref<DataViewFilterBag>(cloneFilterNode(props.modelValue));
     const isNodeExpanded = ref<boolean>(props.isRoot || props.isExpanded);
     const componentDefinition = ref<DataFilterGetComponentResultsBag["componentDefinition"]>();
@@ -346,7 +354,8 @@
         const result = await http.post<DataFilterGetComponentResultsBag>("/api/v2/Controls/DataFilterGetComponent", undefined, {
             entityTypeGuid: props.entityTypeGuid,
             filterTypeGuid: selectedFilterTypeGuidOrEmptyString.value,
-            selection: node.value.selection
+            selection: node.value.selection,
+            securityGrantToken: securityGrantToken.value
         });
 
         if (result.isSuccess && result.data) {
@@ -380,7 +389,8 @@
         const result = await http.post<DataFilterGetSelectionResultsBag>("/api/v2/Controls/DataFilterGetSelection", undefined, {
             entityTypeGuid: props.entityTypeGuid,
             filterTypeGuid: selectedFilterTypeGuidOrEmptyString.value,
-            componentData: componentData.value
+            componentData: componentData.value,
+            securityGrantToken: securityGrantToken.value
         });
 
         if (result.isSuccess && result.data) {
@@ -405,15 +415,18 @@
     }
 
     async function executeComponentRequest(request: Record<string, string>): Promise<Record<string, string> | null> {
-        if (!selectedFilterTypeGuidOrEmptyString.value) {
+        if (!selectedFilterTypeGuidOrEmptyString.value || !props.entityTypeGuid) {
             return null;
         }
 
-        const result = await http.post<Record<string, string>>("/api/v2/Controls/DataFilterExecuteComponentRequest", undefined, {
+        const options: DataFilterExecuteComponentRequestOptionsBag = {
             entityTypeGuid: props.entityTypeGuid,
             filterTypeGuid: selectedFilterTypeGuidOrEmptyString.value,
-            request
-        });
+            request,
+            securityGrantToken: securityGrantToken.value
+        };
+
+        const result = await http.post<Record<string, string>>("/api/v2/Controls/DataFilterExecuteComponentRequest", undefined, options);
 
         if (result.isSuccess) {
             return result.data ?? null;
@@ -499,6 +512,71 @@
         emit("update:modelValue", nextNode);
     }
 
+    function cloneFilterNode(node: DataViewFilterBag | null | undefined): DataViewFilterBag {
+        return JSON.parse(JSON.stringify(node ?? createDefaultDataViewFilter()));
+    }
+
+    function createFilterNode(): DataViewFilterBag {
+        return {
+            guid: newGuid(),
+            expressionType: FilterExpressionType.Filter,
+            filterTypeGuid: null,
+            selection: null,
+            componentData: {},
+            childFilters: []
+        };
+    }
+
+    function createGroupNode(expressionType: FilterExpressionType = FilterExpressionType.GroupAll): DataViewFilterBag {
+        return {
+            guid: newGuid(),
+            expressionType,
+            childFilters: [createFilterNode()]
+        };
+    }
+
+    function createDefaultDataViewFilter(): DataViewFilterBag {
+        return createGroupNode(FilterExpressionType.GroupAll);
+    }
+
+    function isFilterNode(node: DataViewFilterBag): boolean {
+        return node.expressionType === FilterExpressionType.Filter;
+    }
+
+    function getGroupJoinType(expressionType: FilterExpressionType): FilterGroupJoinType {
+        return expressionType === FilterExpressionType.GroupAny || expressionType === FilterExpressionType.GroupAnyFalse
+            ? FilterGroupJoinType.Any
+            : FilterGroupJoinType.All;
+    }
+
+    function getGroupTruthType(expressionType: FilterExpressionType): FilterGroupTruthType {
+        return expressionType === FilterExpressionType.GroupAllFalse || expressionType === FilterExpressionType.GroupAnyFalse
+            ? FilterGroupTruthType.False
+            : FilterGroupTruthType.True;
+    }
+
+    function setGroupJoinType(node: DataViewFilterBag, joinType: FilterGroupJoinType): void {
+        const isFalse = node.expressionType === FilterExpressionType.GroupAllFalse || node.expressionType === FilterExpressionType.GroupAnyFalse;
+
+        if (joinType === FilterGroupJoinType.All) {
+            node.expressionType = isFalse ? FilterExpressionType.GroupAllFalse : FilterExpressionType.GroupAll;
+        }
+        else {
+            node.expressionType = isFalse ? FilterExpressionType.GroupAnyFalse : FilterExpressionType.GroupAny;
+        }
+    }
+
+    function setGroupTruthType(node: DataViewFilterBag, truthType: FilterGroupTruthType): void {
+        const isAll = node.expressionType === FilterExpressionType.GroupAll || node.expressionType === FilterExpressionType.GroupAllFalse;
+
+        if (truthType === FilterGroupTruthType.True) {
+            node.expressionType = isAll ? FilterExpressionType.GroupAll : FilterExpressionType.GroupAny;
+        }
+        else {
+            node.expressionType = isAll ? FilterExpressionType.GroupAllFalse : FilterExpressionType.GroupAnyFalse;
+        }
+    }
+
     watch(() => props.modelValue, async () => {
         const incomingNode = cloneFilterNode(props.modelValue);