Merge remote-tracking branch 'refs/remotes/origin/main' into circleci-integration-branch

backend/src/controllers/v1/integrationAuthController.ts

@@ -1,10 +1,39 @@
-import { Request, Response } from "express";
-import { Types } from "mongoose";
-import * as Sentry from "@sentry/node";
-import { Integration, IntegrationAuth, Bot } from "../../models";
-import { INTEGRATION_SET, INTEGRATION_OPTIONS } from "../../variables";
-import { IntegrationService } from "../../services";
-import { getApps, revokeAccess } from "../../integrations";
+import { Request, Response } from 'express';
+import { Types } from 'mongoose';
+import * as Sentry from '@sentry/node';
+import {
+	Integration, 
+	IntegrationAuth,
+	Bot 
+} from '../../models';
+import { INTEGRATION_SET, INTEGRATION_OPTIONS } from '../../variables';
+import { IntegrationService } from '../../services';
+import { getApps, revokeAccess } from '../../integrations';
+
+/***
+ * Return integration authorization with id [integrationAuthId]
+ */
+export const getIntegrationAuth = async (req: Request, res: Response) => {
+	let integrationAuth;
+	try {
+		const { integrationAuthId } = req.params;
+		integrationAuth = await IntegrationAuth.findById(integrationAuthId);
+		
+		if (!integrationAuth) return res.status(400).send({
+			message: 'Failed to find integration authorization'
+		});
+	} catch (err) {
+		Sentry.setUser({ email: req.user.email });
+		Sentry.captureException(err);
+		return res.status(400).send({
+			message: 'Failed to get integration authorization'
+		});	
+	}
+	
+	return res.status(200).send({
+		integrationAuth
+	});
+}
 
 export const getIntegrationOptions = async (req: Request, res: Response) => {
   return res.status(200).send({
@@ -18,35 +47,37 @@ export const getIntegrationOptions = async (req: Request, res: Response) => {
  * @param res
  * @returns
  */
-export const oAuthExchange = async (req: Request, res: Response) => {
-  try {
-    const { workspaceId, code, integration } = req.body;
-
-    if (!INTEGRATION_SET.has(integration))
-      throw new Error("Failed to validate integration");
-
-    const environments = req.membership.workspace?.environments || [];
-    if (environments.length === 0) {
-      throw new Error("Failed to get environments");
-    }
-
-    await IntegrationService.handleOAuthExchange({
-      workspaceId,
-      integration,
-      code,
-      environment: environments[0].slug,
-    });
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: "Failed to get OAuth2 code-token exchange",
-    });
-  }
-
-  return res.status(200).send({
-    message: "Successfully enabled integration authorization",
-  });
+export const oAuthExchange = async (
+	req: Request,
+	res: Response
+) => {
+	try {
+		const { workspaceId, code, integration } = req.body;
+		if (!INTEGRATION_SET.has(integration))
+			throw new Error('Failed to validate integration');
+		
+		const environments = req.membership.workspace?.environments || [];
+		if(environments.length === 0){
+			throw new Error("Failed to get environments")
+		}
+	
+		const integrationAuth = await IntegrationService.handleOAuthExchange({
+			workspaceId,
+			integration,
+			code,
+			environment: environments[0].slug,
+		});
+		
+		return res.status(200).send({
+			integrationAuth
+		});
+	} catch (err) {
+		Sentry.setUser({ email: req.user.email });
+		Sentry.captureException(err);
+		return res.status(400).send({
+			message: 'Failed to get OAuth2 code-token exchange'
+		});
+	}
 };
 
 /**
@@ -71,50 +102,44 @@ export const saveIntegrationAccessToken = async (
       integration: string;
     } = req.body;
 
-    integrationAuth = await IntegrationAuth.findOneAndUpdate(
-      {
-        workspace: new Types.ObjectId(workspaceId),
-        integration,
-      },
-      {
-        workspace: new Types.ObjectId(workspaceId),
-        integration,
-      },
-      {
-        new: true,
-        upsert: true,
-      }
-    );
+		const bot = await Bot.findOne({
+            workspace: new Types.ObjectId(workspaceId),
+            isActive: true
+        });
+        
+        if (!bot) throw new Error('Bot must be enabled to save integration access token');
 
-    const bot = await Bot.findOne({
-      workspace: new Types.ObjectId(workspaceId),
-      isActive: true,
-    });
-
-    if (!bot)
-      throw new Error("Bot must be enabled to save integration access token");
-
-    // encrypt and save integration access token
-    integrationAuth = await IntegrationService.setIntegrationAuthAccess({
-      integrationAuthId: integrationAuth._id.toString(),
-      accessToken,
-      accessExpiresAt: undefined,
-    });
-
-    if (!integrationAuth)
-      throw new Error("Failed to save integration access token");
-  } catch (err) {
-    Sentry.setUser({ email: req.user.email });
-    Sentry.captureException(err);
-    return res.status(400).send({
-      message: "Failed to save access token for integration",
-    });
-  }
-
-  return res.status(200).send({
-    integrationAuth,
-  });
-};
+		integrationAuth = await IntegrationAuth.findOneAndUpdate({
+            workspace: new Types.ObjectId(workspaceId),
+            integration
+        }, {
+            workspace: new Types.ObjectId(workspaceId),
+            integration
+		}, {
+            new: true,
+            upsert: true
+        });
+		
+		// encrypt and save integration access token
+		integrationAuth = await IntegrationService.setIntegrationAuthAccess({
+			integrationAuthId: integrationAuth._id.toString(),
+			accessToken,
+			accessExpiresAt: undefined
+		});
+		
+		if (!integrationAuth) throw new Error('Failed to save integration access token');
+	} catch (err) {
+		Sentry.setUser({ email: req.user.email });
+		Sentry.captureException(err);
+		return res.status(400).send({
+			message: 'Failed to save access token for integration'
+		});
+	}
+	
+	return res.status(200).send({
+		integrationAuth
+	});
+}
 
 /**
  * Return list of applications allowed for integration with integration authorization id [integrationAuthId]