Feat/activities custom objects (#3213)

* WIP

* WIP - MultiObjectSearch

* WIP

* WIP

* Finished working version

* Fix

* Fixed and cleaned

* Fix

* Disabled files and emails for custom objects

* Cleaned console.log

* Fixed attachment

* Fixed

* fix lint

---------

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

packages/twenty-front/src/modules/activities/hooks/useActivityTargetObjectRecords.ts

@@ -0,0 +1,55 @@
+import { useMemo } from 'react';
+import { useRecoilValue } from 'recoil';
+
+import { ActivityTargetObjectRecord } from '@/activities/types/ActivityTargetObject';
+import { objectMetadataItemsState } from '@/object-metadata/states/objectMetadataItemsState';
+import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
+import { useFindManyRecords } from '@/object-record/hooks/useFindManyRecords';
+import { Nullable } from '~/types/Nullable';
+import { isDefined } from '~/utils/isDefined';
+
+export const useActivityTargetObjectRecords = ({
+  activityId,
+}: {
+  activityId: string;
+}) => {
+  const objectMetadataItems = useRecoilValue(objectMetadataItemsState);
+
+  const { records: activityTargets } = useFindManyRecords({
+    objectNameSingular: CoreObjectNameSingular.ActivityTarget,
+    filter: {
+      activityId: {
+        eq: activityId,
+      },
+    },
+  });
+
+  const activityTargetObjectRecords = useMemo(() => {
+    return activityTargets
+      .map<Nullable<ActivityTargetObjectRecord>>((activityTarget) => {
+        const correspondingObjectMetadataItem = objectMetadataItems.find(
+          (objectMetadataItem) =>
+            isDefined(activityTarget[objectMetadataItem.nameSingular]) &&
+            !objectMetadataItem.isSystem,
+        );
+
+        if (!correspondingObjectMetadataItem) {
+          return null;
+        }
+
+        return {
+          activityTargetRecord: activityTarget,
+          targetObjectRecord:
+            activityTarget[correspondingObjectMetadataItem.nameSingular],
+          targetObjectMetadataItem: correspondingObjectMetadataItem,
+          targetObjectNameSingular:
+            correspondingObjectMetadataItem.nameSingular,
+        };
+      })
+      .filter(isDefined);
+  }, [activityTargets, objectMetadataItems]);
+
+  return {
+    activityTargetObjectRecords,
+  };
+};

packages/twenty-front/src/modules/activities/hooks/useActivityTargets.ts

@@ -0,0 +1,28 @@
+import { ActivityTarget } from '@/activities/types/ActivityTarget';
+import { ActivityTargetableObject } from '@/activities/types/ActivityTargetableEntity';
+import { getActivityTargetObjectFieldIdName } from '@/activities/utils/getTargetObjectFilterFieldName';
+import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
+import { useFindManyRecords } from '@/object-record/hooks/useFindManyRecords';
+
+export const useActivityTargets = ({
+  targetableObject,
+}: {
+  targetableObject: ActivityTargetableObject;
+}) => {
+  const targetObjectFieldName = getActivityTargetObjectFieldIdName({
+    nameSingular: targetableObject.targetObjectNameSingular,
+  });
+
+  const { records: activityTargets } = useFindManyRecords({
+    objectNameSingular: CoreObjectNameSingular.ActivityTarget,
+    filter: {
+      [targetObjectFieldName]: {
+        eq: targetableObject.id,
+      },
+    },
+  });
+
+  return {
+    activityTargets: activityTargets as ActivityTarget[],
+  };
+};

packages/twenty-front/src/modules/activities/hooks/useOpenCreateActivityDrawer.ts

@@ -4,8 +4,10 @@ import { useRecoilState, useRecoilValue } from 'recoil';
 
 import { Activity, ActivityType } from '@/activities/types/Activity';
 import { ActivityTarget } from '@/activities/types/ActivityTarget';
+import { getActivityTargetObjectFieldIdName } from '@/activities/utils/getTargetObjectFilterFieldName';
 import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
 import { CoreObjectNameSingular } from '@/object-metadata/types/CoreObjectNameSingular';
+import { useCreateManyRecords } from '@/object-record/hooks/useCreateManyRecords';
 import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
 import { useRightDrawer } from '@/ui/layout/right-drawer/hooks/useRightDrawer';
 import { RightDrawerHotkeyScope } from '@/ui/layout/right-drawer/types/RightDrawerHotkeyScope';
@@ -14,13 +16,13 @@ import { useSetHotkeyScope } from '@/ui/utilities/hotkey/hooks/useSetHotkeyScope
 
 import { activityTargetableEntityArrayState } from '../states/activityTargetableEntityArrayState';
 import { viewableActivityIdState } from '../states/viewableActivityIdState';
-import { ActivityTargetableEntity } from '../types/ActivityTargetableEntity';
-import { getTargetableEntitiesWithParents } from '../utils/getTargetableEntitiesWithParents';
+import { ActivityTargetableObject } from '../types/ActivityTargetableEntity';
+import { flattenTargetableObjectsAndTheirRelatedTargetableObjects } from '../utils/flattenTargetableObjectsAndTheirRelatedTargetableObjects';
 
 export const useOpenCreateActivityDrawer = () => {
   const { openRightDrawer } = useRightDrawer();
-  const { createOneRecord: createOneActivityTarget } =
-    useCreateOneRecord<ActivityTarget>({
+  const { createManyRecords: createManyActivityTargets } =
+    useCreateManyRecords<ActivityTarget>({
       objectNameSingular: CoreObjectNameSingular.ActivityTarget,
     });
   const { createOneRecord: createOneActivity } = useCreateOneRecord<Activity>({
@@ -37,15 +39,17 @@ export const useOpenCreateActivityDrawer = () => {
   return useCallback(
     async ({
       type,
-      targetableEntities,
+      targetableObjects,
       assigneeId,
     }: {
       type: ActivityType;
-      targetableEntities?: ActivityTargetableEntity[];
+      targetableObjects?: ActivityTargetableObject[];
       assigneeId?: string;
     }) => {
-      const targetableEntitiesWithRelations = targetableEntities
-        ? getTargetableEntitiesWithParents(targetableEntities)
+      const flattenedTargetableObjects = targetableObjects
+        ? flattenTargetableObjectsAndTheirRelatedTargetableObjects(
+            targetableObjects,
+          )
         : [];
 
       const createdActivity = await createOneActivity?.({
@@ -61,21 +65,25 @@ export const useOpenCreateActivityDrawer = () => {
         return;
       }
 
-      await Promise.all(
-        targetableEntitiesWithRelations.map(async (targetableEntity) => {
-          await createOneActivityTarget?.({
-            companyId:
-              targetableEntity.type === 'Company' ? targetableEntity.id : null,
-            personId:
-              targetableEntity.type === 'Person' ? targetableEntity.id : null,
+      const activityTargetsToCreate = flattenedTargetableObjects.map(
+        (targetableObject) => {
+          const targetableObjectFieldIdName =
+            getActivityTargetObjectFieldIdName({
+              nameSingular: targetableObject.targetObjectNameSingular,
+            });
+
+          return {
+            [targetableObjectFieldIdName]: targetableObject.id,
             activityId: createdActivity.id,
-          });
-        }),
+          };
+        },
       );
 
+      await createManyActivityTargets(activityTargetsToCreate);
+
       setHotkeyScope(RightDrawerHotkeyScope.RightDrawer, { goto: false });
       setViewableActivityId(createdActivity.id);
-      setActivityTargetableEntityArray(targetableEntities ?? []);
+      setActivityTargetableEntityArray(targetableObjects ?? []);
       openRightDrawer(RightDrawerPages.CreateActivity);
     },
     [
@@ -84,7 +92,7 @@ export const useOpenCreateActivityDrawer = () => {
       setHotkeyScope,
       setViewableActivityId,
       createOneActivity,
-      createOneActivityTarget,
+      createManyActivityTargets,
       currentWorkspaceMember,
     ],
   );

packages/twenty-front/src/modules/activities/hooks/useOpenCreateActivityDrawerForSelectedRowIds.ts

@@ -4,10 +4,7 @@ import { ActivityType } from '@/activities/types/Activity';
 import { useRecordTableScopedStates } from '@/object-record/record-table/hooks/internal/useRecordTableScopedStates';
 import { getRecordTableScopeInjector } from '@/object-record/record-table/utils/getRecordTableScopeInjector';
 
-import {
-  ActivityTargetableEntity,
-  ActivityTargetableEntityType,
-} from '../types/ActivityTargetableEntity';
+import { ActivityTargetableObject } from '../types/ActivityTargetableEntity';
 
 import { useOpenCreateActivityDrawer } from './useOpenCreateActivityDrawer';
 
@@ -25,8 +22,8 @@ export const useOpenCreateActivityDrawerForSelectedRowIds = (
     ({ snapshot }) =>
       (
         type: ActivityType,
-        entityType: ActivityTargetableEntityType,
-        relatedEntities?: ActivityTargetableEntity[],
+        objectNameSingular: string,
+        relatedEntities?: ActivityTargetableObject[],
       ) => {
         const selectedRowIds =
           injectSelectorSnapshotValueWithRecordTableScopeId(
@@ -34,18 +31,21 @@ export const useOpenCreateActivityDrawerForSelectedRowIds = (
             selectedRowIdsScopeInjector,
           );
 
-        let activityTargetableEntityArray: ActivityTargetableEntity[] =
+        let activityTargetableEntityArray: ActivityTargetableObject[] =
           selectedRowIds.map((id: string) => ({
-            type: entityType,
+            type: 'Custom',
+            targetObjectNameSingular: objectNameSingular,
             id,
           }));
+
         if (relatedEntities) {
           activityTargetableEntityArray =
             activityTargetableEntityArray.concat(relatedEntities);
         }
+
         openCreateActivityDrawer({
           type,
-          targetableEntities: activityTargetableEntityArray,
+          targetableObjects: activityTargetableEntityArray,
         });
       },
     [