Refactor calendar to use new sync statuses and stages (#6141)

- Refactor calendar modules and some messaging modules to better
organize them by business rules and decouple them
- Work toward a common architecture for the different calendar providers
by introducing interfaces for the drivers
- Modify cron job to use the new sync statuses and stages

packages/twenty-server/src/modules/calendar/calendar-event-participant-manager/jobs/calendar-create-company-and-contact-after-sync.job.ts

@@ -0,0 +1,99 @@
+import { Logger, Scope } from '@nestjs/common';
+
+import { IsNull } from 'typeorm';
+
+import { Processor } from 'src/engine/integrations/message-queue/decorators/processor.decorator';
+import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
+import { CreateCompanyAndContactService } from 'src/modules/connected-account/auto-companies-and-contacts-creation/services/create-company-and-contact.service';
+import { Process } from 'src/engine/integrations/message-queue/decorators/process.decorator';
+import { InjectWorkspaceRepository } from 'src/engine/twenty-orm/decorators/inject-workspace-repository.decorator';
+import { WorkspaceRepository } from 'src/engine/twenty-orm/repository/workspace.repository';
+import { CalendarChannelWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
+import { CalendarEventParticipantWorkspaceEntity } from 'src/modules/calendar/common/standard-objects/calendar-event-participant.workspace-entity';
+
+export type CalendarCreateCompanyAndContactAfterSyncJobData = {
+  workspaceId: string;
+  calendarChannelId: string;
+};
+
+@Processor({
+  queueName: MessageQueue.calendarQueue,
+  scope: Scope.REQUEST,
+})
+export class CalendarCreateCompanyAndContactAfterSyncJob {
+  private readonly logger = new Logger(
+    CalendarCreateCompanyAndContactAfterSyncJob.name,
+  );
+  constructor(
+    private readonly createCompanyAndContactService: CreateCompanyAndContactService,
+    @InjectWorkspaceRepository(CalendarChannelWorkspaceEntity)
+    private readonly calendarChannelRepository: WorkspaceRepository<CalendarChannelWorkspaceEntity>,
+    @InjectWorkspaceRepository(CalendarEventParticipantWorkspaceEntity)
+    private readonly calendarEventParticipantRepository: WorkspaceRepository<CalendarEventParticipantWorkspaceEntity>,
+  ) {}
+
+  @Process(CalendarCreateCompanyAndContactAfterSyncJob.name)
+  async handle(
+    data: CalendarCreateCompanyAndContactAfterSyncJobData,
+  ): Promise<void> {
+    this.logger.log(
+      `create contacts and companies after sync for workspace ${data.workspaceId} and calendarChannel ${data.calendarChannelId}`,
+    );
+    const { workspaceId, calendarChannelId } = data;
+
+    const calendarChannel = await this.calendarChannelRepository.findOne({
+      where: {
+        id: calendarChannelId,
+      },
+      relations: ['connectedAccount.accountOwner'],
+    });
+
+    if (!calendarChannel) {
+      throw new Error(
+        `Calendar channel with id ${calendarChannelId} not found in workspace ${workspaceId}`,
+      );
+    }
+
+    const { handle, isContactAutoCreationEnabled, connectedAccount } =
+      calendarChannel;
+
+    if (!isContactAutoCreationEnabled || !handle) {
+      return;
+    }
+
+    if (!connectedAccount) {
+      throw new Error(
+        `Connected account not found in workspace ${workspaceId}`,
+      );
+    }
+
+    const calendarEventParticipantsWithoutPersonIdAndWorkspaceMemberId =
+      await this.calendarEventParticipantRepository.find({
+        where: {
+          calendarEvent: {
+            calendarChannelEventAssociations: {
+              calendarChannelId,
+            },
+            calendarEventParticipants: {
+              person: IsNull(),
+              workspaceMember: IsNull(),
+            },
+          },
+        },
+        relations: [
+          'calendarEvent.calendarChannelEventAssociations',
+          'calendarEvent.calendarEventParticipants',
+        ],
+      });
+
+    await this.createCompanyAndContactService.createCompaniesAndContactsAndUpdateParticipants(
+      connectedAccount,
+      calendarEventParticipantsWithoutPersonIdAndWorkspaceMemberId,
+      workspaceId,
+    );
+
+    this.logger.log(
+      `create contacts and companies after sync for workspace ${data.workspaceId} and calendarChannel ${data.calendarChannelId} done`,
+    );
+  }
+}

packages/twenty-server/src/modules/calendar/calendar-event-participant-manager/jobs/calendar-event-participant-match-participant.job.ts

@@ -0,0 +1,37 @@
+import { Scope } from '@nestjs/common';
+
+import { Process } from 'src/engine/integrations/message-queue/decorators/process.decorator';
+import { Processor } from 'src/engine/integrations/message-queue/decorators/processor.decorator';
+import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
+import { CalendarEventParticipantService } from 'src/modules/calendar/calendar-event-participant-manager/services/calendar-event-participant.service';
+
+export type CalendarEventParticipantMatchParticipantJobData = {
+  workspaceId: string;
+  email: string;
+  personId?: string;
+  workspaceMemberId?: string;
+};
+
+@Processor({
+  queueName: MessageQueue.calendarQueue,
+  scope: Scope.REQUEST,
+})
+export class CalendarEventParticipantMatchParticipantJob {
+  constructor(
+    private readonly calendarEventParticipantService: CalendarEventParticipantService,
+  ) {}
+
+  @Process(CalendarEventParticipantMatchParticipantJob.name)
+  async handle(
+    data: CalendarEventParticipantMatchParticipantJobData,
+  ): Promise<void> {
+    const { workspaceId, email, personId, workspaceMemberId } = data;
+
+    await this.calendarEventParticipantService.matchCalendarEventParticipants(
+      workspaceId,
+      email,
+      personId,
+      workspaceMemberId,
+    );
+  }
+}

packages/twenty-server/src/modules/calendar/calendar-event-participant-manager/jobs/calendar-event-participant-unmatch-participant.job.ts

@@ -0,0 +1,37 @@
+import { Scope } from '@nestjs/common';
+
+import { Processor } from 'src/engine/integrations/message-queue/decorators/processor.decorator';
+import { MessageQueue } from 'src/engine/integrations/message-queue/message-queue.constants';
+import { Process } from 'src/engine/integrations/message-queue/decorators/process.decorator';
+import { CalendarEventParticipantService } from 'src/modules/calendar/calendar-event-participant-manager/services/calendar-event-participant.service';
+
+export type CalendarEventParticipantUnmatchParticipantJobData = {
+  workspaceId: string;
+  email: string;
+  personId?: string;
+  workspaceMemberId?: string;
+};
+
+@Processor({
+  queueName: MessageQueue.calendarQueue,
+  scope: Scope.REQUEST,
+})
+export class CalendarEventParticipantUnmatchParticipantJob {
+  constructor(
+    private readonly calendarEventParticipantService: CalendarEventParticipantService,
+  ) {}
+
+  @Process(CalendarEventParticipantUnmatchParticipantJob.name)
+  async handle(
+    data: CalendarEventParticipantUnmatchParticipantJobData,
+  ): Promise<void> {
+    const { workspaceId, email, personId, workspaceMemberId } = data;
+
+    await this.calendarEventParticipantService.unmatchCalendarEventParticipants(
+      workspaceId,
+      email,
+      personId,
+      workspaceMemberId,
+    );
+  }
+}