7665 handle the select all case inside the action menu (#7742)

Closes #7665 
- Handle select all
- Handle Filters

---------

Co-authored-by: Charles Bochet <charles@twenty.com>

packages/twenty-front/src/modules/context-store/states/contextStoreNumberOfSelectedRecordsState.ts

@@ -0,0 +1,6 @@
+import { createState } from 'twenty-ui';
+
+export const contextStoreNumberOfSelectedRecordsState = createState<number>({
+  key: 'contextStoreNumberOfSelectedRecordsState',
+  defaultValue: 0,
+});

packages/twenty-front/src/modules/context-store/states/contextStoreTargetedRecordIdsState.ts

@@ -1,6 +0,0 @@
-import { createState } from 'twenty-ui';
-
-export const contextStoreTargetedRecordIdsState = createState<string[]>({
-  key: 'contextStoreTargetedRecordIdsState',
-  defaultValue: [],
-});

packages/twenty-front/src/modules/context-store/states/contextStoreTargetedRecordsRuleState.ts

@@ -0,0 +1,26 @@
+import { Filter } from '@/object-record/object-filter-dropdown/types/Filter';
+import { createState } from 'twenty-ui';
+
+type ContextStoreTargetedRecordsRuleSelectionMode = {
+  mode: 'selection';
+  selectedRecordIds: string[];
+};
+
+type ContextStoreTargetedRecordsRuleExclusionMode = {
+  mode: 'exclusion';
+  excludedRecordIds: string[];
+  filters: Filter[];
+};
+
+export type ContextStoreTargetedRecordsRule =
+  | ContextStoreTargetedRecordsRuleSelectionMode
+  | ContextStoreTargetedRecordsRuleExclusionMode;
+
+export const contextStoreTargetedRecordsRuleState =
+  createState<ContextStoreTargetedRecordsRule>({
+    key: 'contextStoreTargetedRecordsRuleState',
+    defaultValue: {
+      mode: 'selection',
+      selectedRecordIds: [],
+    },
+  });

packages/twenty-front/src/modules/context-store/utils/__tests__/computeContextStoreFilters.test.ts

@@ -0,0 +1,77 @@
+import { ContextStoreTargetedRecordsRule } from '@/context-store/states/contextStoreTargetedRecordsRuleState';
+import { computeContextStoreFilters } from '@/context-store/utils/computeContextStoreFilters';
+import { ViewFilterOperand } from '@/views/types/ViewFilterOperand';
+import { generatedMockObjectMetadataItems } from '~/testing/mock-data/generatedMockObjectMetadataItems';
+describe('computeContextStoreFilters', () => {
+  const personObjectMetadataItem = generatedMockObjectMetadataItems.find(
+    (item) => item.nameSingular === 'person',
+  )!;
+
+  it('should work for selection mode', () => {
+    const contextStoreTargetedRecordsRule: ContextStoreTargetedRecordsRule = {
+      mode: 'selection',
+      selectedRecordIds: ['1', '2', '3'],
+    };
+
+    const filters = computeContextStoreFilters(
+      contextStoreTargetedRecordsRule,
+      personObjectMetadataItem,
+    );
+
+    expect(filters).toEqual({
+      id: {
+        in: ['1', '2', '3'],
+      },
+    });
+  });
+
+  it('should work for exclusion mode', () => {
+    const contextStoreTargetedRecordsRule: ContextStoreTargetedRecordsRule = {
+      mode: 'exclusion',
+      filters: [
+        {
+          id: 'name-filter',
+          variant: 'default',
+          fieldMetadataId: personObjectMetadataItem.fields.find(
+            (field) => field.name === 'name',
+          )!.id,
+          value: 'John',
+          displayValue: 'John',
+          displayAvatarUrl: undefined,
+          operand: ViewFilterOperand.Contains,
+          definition: {
+            fieldMetadataId: personObjectMetadataItem.fields.find(
+              (field) => field.name === 'name',
+            )!.id,
+            label: 'Name',
+            iconName: 'person',
+            type: 'TEXT',
+          },
+        },
+      ],
+      excludedRecordIds: ['1', '2', '3'],
+    };
+
+    const filters = computeContextStoreFilters(
+      contextStoreTargetedRecordsRule,
+      personObjectMetadataItem,
+    );
+
+    expect(filters).toEqual({
+      and: [
+        {
+          name: {
+            ilike: '%John%',
+          },
+        },
+        {
+          not: {
+            id: {
+              in: ['1', '2', '3'],
+            },
+          },
+        },
+      ],
+    });
+  });
+});

packages/twenty-front/src/modules/context-store/utils/computeContextStoreFilters.ts

@@ -0,0 +1,42 @@
+import { ContextStoreTargetedRecordsRule } from '@/context-store/states/contextStoreTargetedRecordsRuleState';
+import { ObjectMetadataItem } from '@/object-metadata/types/ObjectMetadataItem';
+import { RecordGqlOperationFilter } from '@/object-record/graphql/types/RecordGqlOperationFilter';
+import { turnFiltersIntoQueryFilter } from '@/object-record/record-filter/utils/turnFiltersIntoQueryFilter';
+import { makeAndFilterVariables } from '@/object-record/utils/makeAndFilterVariables';
+
+export const computeContextStoreFilters = (
+  contextStoreTargetedRecordsRule: ContextStoreTargetedRecordsRule,
+  objectMetadataItem: ObjectMetadataItem,
+) => {
+  let queryFilter: RecordGqlOperationFilter | undefined;
+
+  if (contextStoreTargetedRecordsRule.mode === 'exclusion') {
+    queryFilter = makeAndFilterVariables([
+      turnFiltersIntoQueryFilter(
+        contextStoreTargetedRecordsRule.filters,
+        objectMetadataItem?.fields ?? [],
+      ),
+      contextStoreTargetedRecordsRule.excludedRecordIds.length > 0
+        ? {
+            not: {
+              id: {
+                in: contextStoreTargetedRecordsRule.excludedRecordIds,
+              },
+            },
+          }
+        : undefined,
+    ]);
+  }
+  if (contextStoreTargetedRecordsRule.mode === 'selection') {
+    queryFilter =
+      contextStoreTargetedRecordsRule.selectedRecordIds.length > 0
+        ? {
+            id: {
+              in: contextStoreTargetedRecordsRule.selectedRecordIds,
+            },
+          }
+        : undefined;
+  }
+
+  return queryFilter;
+};