Migrate to a monorepo structure (#2909)

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

@@ -0,0 +1,75 @@
+import { ActivityTarget } from '@/activities/types/ActivityTarget';
+import { useCreateOneRecord } from '@/object-record/hooks/useCreateOneRecord';
+import { useDeleteOneRecord } from '@/object-record/hooks/useDeleteOneRecord';
+
+export const useHandleCheckableActivityTargetChange = ({
+  activityId,
+  currentActivityTargets,
+}: {
+  activityId: string;
+  currentActivityTargets: any[];
+}) => {
+  const { createOneRecord: createOneActivityTarget } =
+    useCreateOneRecord<ActivityTarget>({
+      objectNameSingular: 'activityTarget',
+    });
+  const { deleteOneRecord: deleteOneActivityTarget } = useDeleteOneRecord({
+    objectNameSingular: 'activityTarget',
+  });
+
+  return async (
+    entityValues: Record<string, boolean>,
+    entitiesToSelect: any,
+    selectedEntities: any,
+  ) => {
+    if (!activityId) {
+      return;
+    }
+    const currentActivityTargetRecordIds = currentActivityTargets.map(
+      ({ companyId, personId }) => companyId ?? personId ?? '',
+    );
+
+    const idsToAdd = Object.entries(entityValues)
+      .filter(
+        ([recordId, value]) =>
+          value && !currentActivityTargetRecordIds.includes(recordId),
+      )
+      .map(([id, _]) => id);
+
+    const idsToDelete = Object.entries(entityValues)
+      .filter(([_, value]) => !value)
+      .map(([id, _]) => id);
+
+    if (idsToAdd.length) {
+      idsToAdd.map((id) => {
+        const entityFromToSelect = entitiesToSelect.filter(
+          (entity: any) => entity.id === id,
+        ).length
+          ? entitiesToSelect.filter((entity: any) => entity.id === id)[0]
+          : null;
+
+        const entityFromSelected = selectedEntities.filter(
+          (entity: any) => entity.id === id,
+        ).length
+          ? selectedEntities.filter((entity: any) => entity.id === id)[0]
+          : null;
+
+        const entity = entityFromToSelect ?? entityFromSelected;
+        createOneActivityTarget?.({
+          activityId: activityId,
+          companyId: entity.record.__typename === 'Company' ? entity.id : null,
+          personId: entity.record.__typename === 'Person' ? entity.id : null,
+        });
+      });
+    }
+
+    if (idsToDelete.length) {
+      idsToDelete.map((id) => {
+        const currentActivityTargetId = currentActivityTargets.filter(
+          ({ companyId, personId }) => companyId === id || personId === id,
+        )[0].id;
+        deleteOneActivityTarget?.(currentActivityTargetId);
+      });
+    }
+  };
+};

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

@@ -0,0 +1,20 @@
+import { useRecoilState } from 'recoil';
+
+import { useRightDrawer } from '@/ui/layout/right-drawer/hooks/useRightDrawer';
+import { RightDrawerHotkeyScope } from '@/ui/layout/right-drawer/types/RightDrawerHotkeyScope';
+import { RightDrawerPages } from '@/ui/layout/right-drawer/types/RightDrawerPages';
+import { useSetHotkeyScope } from '@/ui/utilities/hotkey/hooks/useSetHotkeyScope';
+
+import { viewableActivityIdState } from '../states/viewableActivityIdState';
+
+export const useOpenActivityRightDrawer = () => {
+  const { openRightDrawer } = useRightDrawer();
+  const [, setViewableActivityId] = useRecoilState(viewableActivityIdState);
+  const setHotkeyScope = useSetHotkeyScope();
+
+  return (activityId: string) => {
+    setHotkeyScope(RightDrawerHotkeyScope.RightDrawer, { goto: false });
+    setViewableActivityId(activityId);
+    openRightDrawer(RightDrawerPages.EditActivity);
+  };
+};

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

@@ -0,0 +1,91 @@
+import { useCallback } from 'react';
+import { isNonEmptyString } from '@sniptt/guards';
+import { useRecoilState, useRecoilValue } from 'recoil';
+
+import { Activity, ActivityType } from '@/activities/types/Activity';
+import { ActivityTarget } from '@/activities/types/ActivityTarget';
+import { currentWorkspaceMemberState } from '@/auth/states/currentWorkspaceMemberState';
+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';
+import { RightDrawerPages } from '@/ui/layout/right-drawer/types/RightDrawerPages';
+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';
+
+export const useOpenCreateActivityDrawer = () => {
+  const { openRightDrawer } = useRightDrawer();
+  const { createOneRecord: createOneActivityTarget } =
+    useCreateOneRecord<ActivityTarget>({
+      objectNameSingular: 'activityTarget',
+    });
+  const { createOneRecord: createOneActivity } = useCreateOneRecord<Activity>({
+    objectNameSingular: 'activity',
+    refetchFindManyQuery: true,
+  });
+  const currentWorkspaceMember = useRecoilValue(currentWorkspaceMemberState);
+  const setHotkeyScope = useSetHotkeyScope();
+
+  const [, setActivityTargetableEntityArray] = useRecoilState(
+    activityTargetableEntityArrayState,
+  );
+  const [, setViewableActivityId] = useRecoilState(viewableActivityIdState);
+
+  return useCallback(
+    async ({
+      type,
+      targetableEntities,
+      assigneeId,
+    }: {
+      type: ActivityType;
+      targetableEntities?: ActivityTargetableEntity[];
+      assigneeId?: string;
+    }) => {
+      const targetableEntitiesWithRelations = targetableEntities
+        ? getTargetableEntitiesWithParents(targetableEntities)
+        : [];
+
+      const createdActivity = await createOneActivity?.({
+        authorId: currentWorkspaceMember?.id,
+        assigneeId:
+          assigneeId ?? isNonEmptyString(currentWorkspaceMember?.id)
+            ? currentWorkspaceMember?.id
+            : undefined,
+        type: type,
+      });
+
+      if (!createdActivity) {
+        return;
+      }
+
+      await Promise.all(
+        targetableEntitiesWithRelations.map(async (targetableEntity) => {
+          await createOneActivityTarget?.({
+            companyId:
+              targetableEntity.type === 'Company' ? targetableEntity.id : null,
+            personId:
+              targetableEntity.type === 'Person' ? targetableEntity.id : null,
+            activityId: createdActivity.id,
+          });
+        }),
+      );
+
+      setHotkeyScope(RightDrawerHotkeyScope.RightDrawer, { goto: false });
+      setViewableActivityId(createdActivity.id);
+      setActivityTargetableEntityArray(targetableEntities ?? []);
+      openRightDrawer(RightDrawerPages.CreateActivity);
+    },
+    [
+      openRightDrawer,
+      setActivityTargetableEntityArray,
+      setHotkeyScope,
+      setViewableActivityId,
+      createOneActivity,
+      createOneActivityTarget,
+      currentWorkspaceMember,
+    ],
+  );
+};

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

@@ -0,0 +1,42 @@
+import { useRecoilCallback } from 'recoil';
+
+import { ActivityType } from '@/activities/types/Activity';
+import { selectedRowIdsSelector } from '@/object-record/record-table/states/selectors/selectedRowIdsSelector';
+
+import {
+  ActivityTargetableEntity,
+  ActivityTargetableEntityType,
+} from '../types/ActivityTargetableEntity';
+
+import { useOpenCreateActivityDrawer } from './useOpenCreateActivityDrawer';
+
+export const useOpenCreateActivityDrawerForSelectedRowIds = () => {
+  const openCreateActivityDrawer = useOpenCreateActivityDrawer();
+
+  return useRecoilCallback(
+    ({ snapshot }) =>
+      (
+        type: ActivityType,
+        entityType: ActivityTargetableEntityType,
+        relatedEntities?: ActivityTargetableEntity[],
+      ) => {
+        const selectedRowIds = Object.keys(
+          snapshot.getLoadable(selectedRowIdsSelector).getValue(),
+        );
+        let activityTargetableEntityArray: ActivityTargetableEntity[] =
+          selectedRowIds.map((id) => ({
+            type: entityType,
+            id,
+          }));
+        if (relatedEntities) {
+          activityTargetableEntityArray =
+            activityTargetableEntityArray.concat(relatedEntities);
+        }
+        openCreateActivityDrawer({
+          type,
+          targetableEntities: activityTargetableEntityArray,
+        });
+      },
+    [openCreateActivityDrawer],
+  );
+};