Fix Tasks and Activities - Part 1 (#2624)

Fixed

front/src/modules/activities/tasks/hooks/useTasks.ts

@@ -2,55 +2,108 @@ import { DateTime } from 'luxon';
 
 import { Activity } from '@/activities/types/Activity';
 import { ActivityTargetableEntity } from '@/activities/types/ActivityTargetableEntity';
+import { useOptimisticEffect } from '@/apollo/optimistic-effect/hooks/useOptimisticEffect';
+import { useObjectMetadataItem } from '@/object-metadata/hooks/useObjectMetadataItem';
+import { getRecordOptimisticEffectDefinition } from '@/object-record/graphql/optimistic-effect-definition/getRecordOptimisticEffectDefinition';
 import { useFindManyObjectRecords } from '@/object-record/hooks/useFindManyObjectRecords';
 import { useFilter } from '@/ui/object/object-filter-dropdown/hooks/useFilter';
-import { turnFiltersIntoWhereClauseV2 } from '@/ui/object/object-filter-dropdown/utils/turnFiltersIntoWhereClauseV2';
 import { parseDate } from '~/utils/date-utils';
 
 export const useTasks = (entity?: ActivityTargetableEntity) => {
   const { selectedFilter } = useFilter();
 
-  const whereFilters = entity
-    ? {
-        activityTargets: {
-          some: {
-            OR: [
-              { companyId: { equals: entity.id } },
-              { personId: { equals: entity.id } },
-            ],
-          },
-        },
-      }
-    : Object.assign({}, turnFiltersIntoWhereClauseV2([], []));
+  const { objects: activityTargets } = useFindManyObjectRecords({
+    objectNamePlural: 'activityTargets',
+    filter: {
+      [entity?.type === 'Company' ? 'companyId' : 'personId']: {
+        eq: entity?.id,
+      },
+    },
+  });
+
+  const { objectMetadataItem: activityObjectMetadataItem } =
+    useObjectMetadataItem({
+      objectNameSingular: 'activity',
+    });
+
+  const { registerOptimisticEffect } = useOptimisticEffect({
+    objectNameSingular: activityObjectMetadataItem?.nameSingular,
+  });
 
   const { objects: completeTasksData } = useFindManyObjectRecords({
     objectNamePlural: 'activities',
     skip: !entity && !selectedFilter,
     filter: {
-      type: { equals: 'Task' },
       completedAt: { is: 'NOT_NULL' },
-      ...whereFilters,
-    },
-    orderBy: [
-      {
-        createdAt: 'AscNullIsFirst',
+      id: {
+        in: activityTargets?.map((activityTarget) => activityTarget.activityId),
       },
-    ],
+      type: { eq: 'Task' },
+    },
+    orderBy: {
+      createdAt: 'DescNullsFirst',
+    },
+    onCompleted: () => {
+      if (activityObjectMetadataItem) {
+        registerOptimisticEffect({
+          variables: {
+            filter: {
+              completedAt: { is: 'NOT_NULL' },
+              id: {
+                in: activityTargets?.map(
+                  (activityTarget) => activityTarget.activityId,
+                ),
+              },
+              type: { eq: 'Task' },
+            },
+            orderBy: {
+              createdAt: 'DescNullsFirst',
+            },
+          },
+          definition: getRecordOptimisticEffectDefinition({
+            objectMetadataItem: activityObjectMetadataItem,
+          }),
+        });
+      }
+    },
   });
 
   const { objects: incompleteTaskData } = useFindManyObjectRecords({
     objectNamePlural: 'activities',
     skip: !entity && !selectedFilter,
     filter: {
-      type: { equals: 'Task' },
       completedAt: { is: 'NULL' },
-      ...whereFilters,
-    },
-    orderBy: [
-      {
-        createdAt: 'DescNullIsFirst',
+      id: {
+        in: activityTargets?.map((activityTarget) => activityTarget.activityId),
       },
-    ],
+      type: { eq: 'Task' },
+    },
+    orderBy: {
+      createdAt: 'DescNullsFirst',
+    },
+    onCompleted: () => {
+      if (activityObjectMetadataItem) {
+        registerOptimisticEffect({
+          variables: {
+            filter: {
+              completedAt: { is: 'NULL' },
+              id: {
+                in: activityTargets?.map(
+                  (activityTarget) => activityTarget.activityId,
+                ),
+              },
+              type: { eq: 'Task' },
+            },
+            orderBy: {
+              createdAt: 'DescNullsFirst',
+            },
+          },
+          definition: getRecordOptimisticEffectDefinition({
+            objectMetadataItem: activityObjectMetadataItem,
+          }),
+        });
+      }
+    },
   });
 
   const todayOrPreviousTasks = incompleteTaskData?.filter((task) => {