6657 Refactor and fix blocklist (#6803)

Closes #6657
- Fix listeners
- Refactor jobs to take array of events
- Fix calendar events and messages deletion

---------

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

packages/twenty-server/src/modules/calendar/common/calendar-common.module.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+
+import { FeatureFlagEntity } from 'src/engine/core-modules/feature-flag/feature-flag.entity';
+import { WorkspaceDataSourceModule } from 'src/engine/workspace-datasource/workspace-datasource.module';
+import { CalendarChannelSyncStatusService } from 'src/modules/calendar/common/services/calendar-channel-sync-status.service';
+import { ConnectedAccountModule } from 'src/modules/connected-account/connected-account.module';
+
+@Module({
+  imports: [
+    WorkspaceDataSourceModule,
+    TypeOrmModule.forFeature([FeatureFlagEntity], 'core'),
+    ConnectedAccountModule,
+  ],
+  providers: [CalendarChannelSyncStatusService],
+  exports: [CalendarChannelSyncStatusService],
+})
+export class CalendarCommonModule {}

packages/twenty-server/src/modules/calendar/common/services/calendar-channel-sync-status.service.ts

@@ -0,0 +1,290 @@
+import { Injectable } from '@nestjs/common';
+
+import { Any } from 'typeorm';
+
+import { CacheStorageService } from 'src/engine/integrations/cache-storage/cache-storage.service';
+import { InjectCacheStorage } from 'src/engine/integrations/cache-storage/decorators/cache-storage.decorator';
+import { CacheStorageNamespace } from 'src/engine/integrations/cache-storage/types/cache-storage-namespace.enum';
+import { TwentyORMManager } from 'src/engine/twenty-orm/twenty-orm.manager';
+import {
+  CalendarChannelSyncStage,
+  CalendarChannelSyncStatus,
+  CalendarChannelWorkspaceEntity,
+} from 'src/modules/calendar/common/standard-objects/calendar-channel.workspace-entity';
+import { AccountsToReconnectService } from 'src/modules/connected-account/services/accounts-to-reconnect.service';
+import { ConnectedAccountWorkspaceEntity } from 'src/modules/connected-account/standard-objects/connected-account.workspace-entity';
+import { AccountsToReconnectKeys } from 'src/modules/connected-account/types/accounts-to-reconnect-key-value.type';
+
+@Injectable()
+export class CalendarChannelSyncStatusService {
+  constructor(
+    private readonly twentyORMManager: TwentyORMManager,
+    @InjectCacheStorage(CacheStorageNamespace.ModuleCalendar)
+    private readonly cacheStorage: CacheStorageService,
+    private readonly accountsToReconnectService: AccountsToReconnectService,
+  ) {}
+
+  public async scheduleFullCalendarEventListFetch(
+    calendarChannelIds: string[],
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStage:
+        CalendarChannelSyncStage.FULL_CALENDAR_EVENT_LIST_FETCH_PENDING,
+    });
+  }
+
+  public async schedulePartialCalendarEventListFetch(
+    calendarChannelIds: string[],
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStage:
+        CalendarChannelSyncStage.PARTIAL_CALENDAR_EVENT_LIST_FETCH_PENDING,
+    });
+  }
+
+  public async markAsCalendarEventListFetchOngoing(
+    calendarChannelIds: string[],
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStage: CalendarChannelSyncStage.CALENDAR_EVENT_LIST_FETCH_ONGOING,
+      syncStatus: CalendarChannelSyncStatus.ONGOING,
+      syncStageStartedAt: new Date().toISOString(),
+    });
+  }
+
+  public async resetAndScheduleFullCalendarEventListFetch(
+    calendarChannelIds: string[],
+    workspaceId: string,
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    for (const calendarChannelId of calendarChannelIds) {
+      await this.cacheStorage.del(
+        `calendar-events-to-import:${workspaceId}:google-calendar:${calendarChannelId}`,
+      );
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncCursor: '',
+      syncStageStartedAt: null,
+      throttleFailureCount: 0,
+    });
+
+    await this.scheduleFullCalendarEventListFetch(calendarChannelIds);
+  }
+
+  public async resetSyncStageStartedAt(calendarChannelIds: string[]) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStageStartedAt: null,
+    });
+  }
+
+  public async scheduleCalendarEventsImport(calendarChannelIds: string[]) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStage: CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_PENDING,
+    });
+  }
+
+  public async markAsCalendarEventsImportOngoing(calendarChannelIds: string[]) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStage: CalendarChannelSyncStage.CALENDAR_EVENTS_IMPORT_ONGOING,
+      syncStatus: CalendarChannelSyncStatus.ONGOING,
+    });
+  }
+
+  public async markAsCompletedAndSchedulePartialCalendarEventListFetch(
+    calendarChannelIds: string[],
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStage:
+        CalendarChannelSyncStage.PARTIAL_CALENDAR_EVENT_LIST_FETCH_PENDING,
+      syncStatus: CalendarChannelSyncStatus.ACTIVE,
+      throttleFailureCount: 0,
+      syncStageStartedAt: null,
+    });
+
+    await this.schedulePartialCalendarEventListFetch(calendarChannelIds);
+  }
+
+  public async markAsFailedUnknownAndFlushCalendarEventsToImport(
+    calendarChannelIds: string[],
+    workspaceId: string,
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    for (const calendarChannelId of calendarChannelIds) {
+      await this.cacheStorage.del(
+        `calendar-events-to-import:${workspaceId}:google-calendar:${calendarChannelId}`,
+      );
+    }
+
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStatus: CalendarChannelSyncStatus.FAILED_UNKNOWN,
+      syncStage: CalendarChannelSyncStage.FAILED,
+    });
+  }
+
+  public async markAsFailedInsufficientPermissionsAndFlushCalendarEventsToImport(
+    calendarChannelIds: string[],
+    workspaceId: string,
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    for (const calendarChannelId of calendarChannelIds) {
+      await this.cacheStorage.del(
+        `calendar-events-to-import:${workspaceId}:google-calendar:${calendarChannelId}`,
+      );
+    }
+    await calendarChannelRepository.update(calendarChannelIds, {
+      syncStatus: CalendarChannelSyncStatus.FAILED_INSUFFICIENT_PERMISSIONS,
+      syncStage: CalendarChannelSyncStage.FAILED,
+    });
+
+    const connectedAccountRepository =
+      await this.twentyORMManager.getRepository<ConnectedAccountWorkspaceEntity>(
+        'connectedAccount',
+      );
+
+    const calendarChannels = await calendarChannelRepository.find({
+      select: ['id', 'connectedAccountId'],
+      where: { id: Any(calendarChannelIds) },
+    });
+
+    const connectedAccountIds = calendarChannels.map(
+      (calendarChannel) => calendarChannel.connectedAccountId,
+    );
+
+    await connectedAccountRepository.update(
+      { id: Any(connectedAccountIds) },
+      {
+        authFailedAt: new Date(),
+      },
+    );
+
+    await this.addToAccountsToReconnect(
+      calendarChannels.map((calendarChannel) => calendarChannel.id),
+      workspaceId,
+    );
+  }
+
+  private async addToAccountsToReconnect(
+    calendarChannelIds: string[],
+    workspaceId: string,
+  ) {
+    if (!calendarChannelIds.length) {
+      return;
+    }
+
+    const calendarChannelRepository =
+      await this.twentyORMManager.getRepository<CalendarChannelWorkspaceEntity>(
+        'calendarChannel',
+      );
+
+    const calendarChannels = await calendarChannelRepository.find({
+      where: {
+        id: Any(calendarChannelIds),
+      },
+      relations: {
+        connectedAccount: {
+          accountOwner: true,
+        },
+      },
+    });
+
+    for (const calendarChannel of calendarChannels) {
+      const userId = calendarChannel.connectedAccount.accountOwner.userId;
+      const connectedAccountId = calendarChannel.connectedAccount.id;
+
+      await this.accountsToReconnectService.addAccountToReconnectByKey(
+        AccountsToReconnectKeys.ACCOUNTS_TO_RECONNECT_INSUFFICIENT_PERMISSIONS,
+        userId,
+        workspaceId,
+        connectedAccountId,
+      );
+    }
+  }
+}