Merge pull request #451 from TogetherCrew/handle-website-workflows

Handle website workflows

Author: cyri113

src/controllers/hivemind.controller.ts

@@ -9,7 +9,12 @@ const askQuestion = catchAsync(async function (req: IAuthRequest, res: Response)
   console.debug('Body', req.body.communityId, req.body.question, req.body.chatId);
   req.setTimeout(6 * 60 * 1000);
   res.setTimeout(6 * 60 * 1000);
-  const answer = await HivemindTemporalService.triggerWorkflow(req.body.communityId, req.body.question, false, req.body.chatId);
+  const answer = await HivemindTemporalService.triggerWorkflow(
+    req.body.communityId,
+    req.body.question,
+    false,
+    req.body.chatId,
+  );
   res.status(httpStatus.OK).send({ answer });
 });
 

src/controllers/platform.controller.ts

@@ -324,13 +324,7 @@ const getPlatform = catchAsync(async function (req: IAuthRequest, res: Response)
 });
 const updatePlatform = catchAsync(async function (req: IAuthAndPlatform, res: Response) {
   platformService.validatePlatformUpdate(req.platform, req.body);
-  if (req.platform.name === PlatformNames.Discord) {
-    const discordIdentity = userService.getIdentityByProvider(req.user.identities, PlatformNames.Discord);
-    if (discordIdentity) {
-      await platformService.notifyDiscordUserImportComplete(req.platform.id, discordIdentity.id);
-    }
-  }
-  const platform = await platformService.updatePlatform(req.platform, req.body);
+  const platform = await platformService.updatePlatform(req.platform, req.user, req.body);
   res.send(platform);
 });
 const deletePlatform = catchAsync(async function (req: IAuthAndPlatform, res: Response) {

src/services/module.service.ts

@@ -63,31 +63,68 @@ const updateModule = async (
   module: HydratedDocument<IModule>,
   updateBody: Partial<IModuleUpdateBody>,
 ): Promise<HydratedDocument<IModule>> => {
-  if (updateBody.options && updateBody.options.platforms) {
-    if (updateBody.options.platforms[0].name == undefined) {
-      {
-        const globalOption = module.options?.platforms[0];
-        if (globalOption) globalOption.metadata = updateBody.options.platforms[0].metadata;
-        else module.options?.platforms.push(updateBody.options.platforms[0]);
-      }
+  if (!updateBody.options?.platforms?.length) {
+    return module.save();
+  }
+
+  if (!module.options) {
+    module.options = { platforms: [] };
+  } else if (!module.options.platforms) {
+    module.options.platforms = [];
+  }
+
+  const platforms = updateBody.options.platforms;
+
+  if (platforms[0].name === undefined) {
+    const globalOption = module.options.platforms[0];
+    if (globalOption) {
+      globalOption.metadata = platforms[0].metadata;
+    } else {
+      module.options.platforms.push(platforms[0]);
+    }
+    return module.save();
+  }
+
+  for (const newPlatform of platforms) {
+    const existingPlatform = module.options.platforms.find((p) => p.name === newPlatform.name);
+
+    if (existingPlatform) {
+      existingPlatform.metadata = newPlatform.metadata;
     } else {
-      for (const newPlatform of updateBody.options.platforms) {
-        const existingPlatform = module.options?.platforms.find((p) => p.name === newPlatform.name);
-        if (existingPlatform) {
-          existingPlatform.metadata = newPlatform.metadata;
-        } else {
-          module.options?.platforms.push(newPlatform);
-          if (module.name === ModuleNames.Hivemind && newPlatform.name === PlatformNames.Website) {
-            const scheduleId = await websiteService.coreService.createWebsiteSchedule(newPlatform.platform);
-            const platform = await platformService.getPlatformById(newPlatform.platform);
-            platform?.set('metadata.scheduleId', scheduleId);
-            await platform?.save();
-          }
-        }
+      module.options.platforms.push(newPlatform);
+      if (module.name === ModuleNames.Hivemind && newPlatform.name === PlatformNames.Website) {
+        await handleHivemindWebsiteCase(newPlatform);
       }
     }
   }
-  return await module.save();
+  return module.save();
+};
+
+/**
+ * Handle special case for Hivemind module with Website platform
+ * @param {Object} platform - Platform object
+ */
+const handleHivemindWebsiteCase = async (platform: any) => {
+  const platformDoc = await platformService.getPlatformById(platform.platform);
+
+  if (!platformDoc) return;
+
+  const isActivated = platform.metadata?.activated;
+  const existingScheduleId = platformDoc.get('metadata.scheduleId');
+
+  if (isActivated === true) {
+    if (!existingScheduleId) {
+      const scheduleId = await websiteService.coreService.createWebsiteSchedule(platform.platform);
+      platformDoc.set('metadata.scheduleId', scheduleId);
+      await platformDoc.save();
+    }
+  } else if (isActivated === false) {
+    if (existingScheduleId) {
+      await websiteService.coreService.deleteWebsiteSchedule(existingScheduleId);
+      platformDoc.set('metadata.scheduleId', null);
+      await platformDoc.save();
+    }
+  }
 };
 
 /**

src/services/platform.service.ts

@@ -2,15 +2,19 @@ import { Snowflake } from 'discord.js';
 import httpStatus from 'http-status';
 import { FilterQuery, HydratedDocument, ObjectId, Types } from 'mongoose';
 
-import { IPlatform, IUser, Platform, PlatformNames } from '@togethercrew.dev/db';
+import { IPlatform, IUser, ModuleNames, Platform, PlatformNames } from '@togethercrew.dev/db';
 
 import { analyzerAction, analyzerWindow } from '../config/analyzer.statics';
 import parentLogger from '../config/logger';
 import { IAuthAndPlatform } from '../interfaces/Request.interface';
 import ApiError from '../utils/ApiError';
+import { platformService } from './';
 import discourseService from './discourse';
+import moduleService from './module.service';
 import reputationScoreService from './reputationScore.service';
 import sagaService from './saga.service';
+import userService from './user.service';
+import websiteService from './website';
 
 const logger = parentLogger.child({ module: 'PlatformService' });
 /**
@@ -120,8 +124,20 @@ const updatePlatformByFilter = async (
  */
 const updatePlatform = async (
   platform: HydratedDocument<IPlatform>,
+  user: HydratedDocument<IUser>,
   updateBody: Partial<IPlatform>,
 ): Promise<HydratedDocument<IPlatform>> => {
+  // Handle special cases based on platform type
+  if (platform.name === PlatformNames.Website) {
+    await handleWebsiteResourceChanges(platform, updateBody);
+  }
+  if (platform.name === PlatformNames.Discord) {
+    const discordIdentity = userService.getIdentityByProvider(user.identities, PlatformNames.Discord);
+    if (discordIdentity) {
+      await platformService.notifyDiscordUserImportComplete(platform.id, discordIdentity.id);
+    }
+  }
+
   if (updateBody.metadata) {
     updateBody.metadata = {
       ...platform.metadata,
@@ -139,15 +155,7 @@ const updatePlatform = async (
  * @returns {Promise<HydratedDocument<IPlatform>>}
  */
 const deletePlatform = async (platform: HydratedDocument<IPlatform>): Promise<HydratedDocument<IPlatform>> => {
-  switch (platform.name) {
-    case PlatformNames.Discourse: {
-      if (platform.metadata?.scheduleId) {
-        await discourseService.coreService.deleteDiscourseSchedule(platform.metadata.scheduleId);
-      }
-    }
-    default: {
-    }
-  }
+  await handlePlatformCleanup(platform);
   return await platform.remove();
 };
 
@@ -321,6 +329,75 @@ const getReputationScore = async (platform: HydratedDocument<IPlatform>, user: H
     reputationScore: (await reputationScoreService.calculateReputationScoreForUser(platform, identity.id)) * 100,
   };
 };
+
+/**
+ * Handle platform-specific cleanup during deletion
+ * @param {HydratedDocument<IPlatform>} platform - Platform document
+ * @returns {Promise<void>}
+ */
+const handlePlatformCleanup = async (platform: HydratedDocument<IPlatform>): Promise<void> => {
+  switch (platform.name) {
+    case PlatformNames.Discourse: {
+      if (platform.metadata?.scheduleId) {
+        await discourseService.coreService.deleteDiscourseSchedule(platform.metadata.scheduleId);
+      }
+      break;
+    }
+    case PlatformNames.Website: {
+      if (platform.metadata?.scheduleId) {
+        await websiteService.coreService.deleteWebsiteSchedule(platform.metadata.scheduleId);
+      }
+      break;
+    }
+    default:
+      break;
+  }
+};
+
+/**
+ * Handle Website platform resource changes
+ * @param {HydratedDocument<IPlatform>} platform - Platform document
+ * @param {Partial<IPlatform>} updateBody - Update body
+ * @returns {Promise<void>}
+ */
+const handleWebsiteResourceChanges = async (
+  platform: HydratedDocument<IPlatform>,
+  updateBody: Partial<IPlatform>,
+): Promise<void> => {
+  if (!updateBody.metadata?.resources || !platform.metadata?.resources) {
+    return;
+  }
+  const oldResources = JSON.stringify(platform.metadata.resources.sort());
+  const newResources = JSON.stringify(updateBody.metadata.resources.sort());
+
+  if (oldResources !== newResources) {
+    const existingScheduleId = platform.metadata.scheduleId;
+
+    if (existingScheduleId) {
+      await websiteService.coreService.deleteWebsiteSchedule(existingScheduleId);
+      updateBody.metadata.scheduleId = null;
+    }
+
+    const moduleFilter = {
+      name: ModuleNames.Hivemind,
+      'options.platforms': {
+        $elemMatch: {
+          name: PlatformNames.Website,
+          platform: platform._id,
+          'metadata.activated': true,
+        },
+      },
+    };
+
+    const hivemindModule = await moduleService.getModuleByFilter(moduleFilter);
+
+    if (hivemindModule) {
+      const scheduleId = await websiteService.coreService.createWebsiteSchedule(platform._id);
+      updateBody.metadata.scheduleId = scheduleId;
+    }
+  }
+};
+
 export default {
   createPlatform,
   getPlatformById,