Merge main

src/modules/inputs/inputs.controller.ts

@@ -10,7 +10,6 @@ import {
 import { InputsService } from './inputs.service';
 import { InputsClientService } from 'src/clients/inputs/client.service';
 import { UpdateInputRequest } from 'src/clients/inputs/interfaces';
-import { InputNewCreateRequest } from '@victorradael/protospack';
 import { Permissions } from '../../authentication/permissions.enum';
 import { AuthenticateCondition } from 'src/authentication/authentication.decorator';
 import { ApiOkResponse, ApiTags } from '@nestjs/swagger';

src/modules/oauth/oauth.controller.ts

@@ -1,16 +1,9 @@
-import {
-  BadRequestException,
-  Controller,
-  Get,
-  Query,
-  Redirect,
-  Req,
-  UseGuards,
-} from '@nestjs/common';
+import { Controller, Get, Redirect, Req, UseGuards } from '@nestjs/common';
 import { ApiTags } from '@nestjs/swagger';
 import { AuthGuard } from '@nestjs/passport';
 import { InputsClientService } from 'src/clients/inputs/client.service';
 import { InputsService } from '../inputs/inputs.service';
+import { Request } from 'express';
 
 @ApiTags('oauth')
 @Controller('oauth')
@@ -40,15 +33,85 @@ export class OauthController {
   @Get('hubspot/callback')
   @UseGuards(AuthGuard('hubspot'))
   @Redirect()
-  async oauthHubspotCallback(@Req() req, @Query('state') customer_id) {
-    const { authInfo } = req;
-    if (!authInfo) throw new BadRequestException('Oauth tokens not found');
-    const { accessToken, refreshToken } = authInfo;
+  async oauthHubspotCallback(@Req() req) {
+    return await this.callback(req, 'hubspot');
+  }
+
+  @Get('googleads')
+  @UseGuards(AuthGuard('google'))
+  async oauthGoogleAds() {
+    return true;
+  }
+
+  @Get('googleads/callback')
+  @UseGuards(AuthGuard('google'))
+  @Redirect()
+  async oauthGoogleAdsCallback(@Req() req) {
+    return await this.callback(req, 'googleads');
+  }
+
+  @Get('google-sheets')
+  @UseGuards(AuthGuard('google'))
+  async oauthGoogleSheets() {
+    return true;
+  }
+
+  @Get('google-sheets/callback')
+  @UseGuards(AuthGuard('google'))
+  @Redirect()
+  async oauthGoogleSheetsCallback(@Req() req) {
+    return await this.callback(req, 'google-sheets');
+  }
+
+  @Get('facebook')
+  @UseGuards(AuthGuard('facebook'))
+  async oauthFacebook() {
+    return true;
+  }
+
+  @Get('facebook/callback')
+  @UseGuards(AuthGuard('facebook'))
+  @Redirect()
+  async oauthFacebookCallback(@Req() req) {
+    return await this.callback(req, 'facebook');
+  }
+
+  @Get('mailchimp')
+  @UseGuards(AuthGuard('mailchimp'))
+  async oauthMailchimp() {
+    return true;
+  }
+
+  @Get('mailchimp/callback')
+  @UseGuards(AuthGuard('mailchimp'))
+  @Redirect()
+  async oauthMailchimpCallback(@Req() req) {
+    return await this.callback(req, 'mailchimp');
+  }
+
+  async callback(@Req() req: Request, plugin) {
+    const { error, state: customer_id } = req.query;
+
+    if (error)
+      return {
+        url: `${this.frontendRedirectUri}?error=${error}`,
+      };
+    const request: any = req;
+    const { authInfo } = request;
+
+    if (!authInfo)
+      return {
+        url: `${this.frontendRedirectUri}?error=invalid_credentials`,
+      };
+
+    const { accessToken: access_token, refreshToken: refresh_token } = authInfo;
+
     const response = await this.inputService.create({
       info: { customer_id, customer: 'customer', user_id: 'empty' },
-      plugin: 'hubspot',
-      credentials: { access_token: accessToken, refresh_token: refreshToken },
+      plugin,
+      credentials: { access_token, refresh_token },
     });
+
     return { url: `${this.frontendRedirectUri}?input_id=${response.input.id}` };
   }
 }

src/modules/oauth/passport-strategies/facebook-strategy.ts

@@ -0,0 +1,32 @@
+import {
+  Profile,
+  Strategy,
+  StrategyOptionWithRequest,
+  VerifyFunction,
+} from 'passport-facebook';
+import { PassportStrategy } from '@nestjs/passport';
+import { Inject, Injectable } from '@nestjs/common';
+import { OauthSecrets } from 'src/utils/OauthSecrets';
+
+@Injectable()
+export class FacebookStrategy extends PassportStrategy(Strategy) {
+  constructor(
+    @Inject('OAUTH_SECRETS')
+    private readonly oauthSecrets: OauthSecrets,
+  ) {
+    const options: StrategyOptionWithRequest = {
+      clientID: oauthSecrets.facebook.client_id,
+      clientSecret: oauthSecrets.facebook.client_secret,
+      callbackURL: oauthSecrets.facebook.redirect_uri,
+      passReqToCallback: true,
+    };
+    const verify: VerifyFunction = (
+      accessToken: string,
+      refreshToken: string,
+      profile: Profile,
+      done: (error: any, user?: any, info?: any) => void,
+    ) => done(null, profile, { accessToken, refreshToken });
+
+    super(options, verify);
+  }
+}

src/modules/oauth/passport-strategies/google-strategy.ts

@@ -0,0 +1,68 @@
+import { Profile, Strategy, StrategyOptions } from 'passport-google-oauth20';
+import { PassportStrategy } from '@nestjs/passport';
+import { Inject, Injectable } from '@nestjs/common';
+import { OauthSecrets } from 'src/utils/OauthSecrets';
+
+@Injectable()
+export class GoogleStrategy extends PassportStrategy(Strategy, 'google') {
+  redirect_uri: string;
+  constructor(
+    @Inject('OAUTH_SECRETS')
+    private readonly oauthSecrets: OauthSecrets,
+  ) {
+    const options: StrategyOptions = {
+      clientID: oauthSecrets.google.client_id,
+      clientSecret: oauthSecrets.google.client_secret,
+      callbackURL: '/oauth/googleads/callback',
+    };
+    const verify = (
+      accessToken: string,
+      refreshToken: string,
+      profile: Profile,
+      done,
+    ) => {
+      console.log('verify');
+      return done(null, profile, { accessToken, refreshToken });
+    };
+
+    super(options, verify);
+    switch (process.env.ENV) {
+      case 'dev':
+      case 'stg':
+        this.redirect_uri = `https://maestro.${process.env.ENV}.dadosfera.ai/oauth`;
+        break;
+      case 'prd':
+        this.redirect_uri = `https://maestro.dadosfera.ai/oauth`;
+        break;
+      default:
+        this.redirect_uri = `/oauth`;
+        break;
+    }
+  }
+
+  authenticate(req, options) {
+    const plugin: string = req.route.path
+      .replace('/oauth/', '')
+      .replace('/callback', '');
+
+    const { customer_id } = req.query;
+    options.scope = ['https://www.googleapis.com/auth/userinfo.email'];
+    options.callbackURL = `${this.redirect_uri}/${plugin}/callback`;
+
+    switch (plugin) {
+      case 'googleads':
+        options.scope.push('https://www.googleapis.com/auth/adwords');
+        break;
+      case 'google-sheets':
+        options.scope.push(
+          'https://www.googleapis.com/auth/drive.metadata.readonly',
+          'https://www.googleapis.com/auth/spreadsheets.readonly',
+        );
+        break;
+    }
+    options.state = customer_id;
+    options.accessType = 'offline';
+    options.prompt = 'consent';
+    super.authenticate(req, options);
+  }
+}

src/modules/oauth/passport-strategies/mailchimp-strategy.ts

@@ -0,0 +1,35 @@
+import { Strategy } from 'passport-mailchimp';
+import { PassportStrategy } from '@nestjs/passport';
+import { Inject, Injectable, Req } from '@nestjs/common';
+import { OauthSecrets } from 'src/utils/OauthSecrets';
+
+@Injectable()
+export class MailChimpStrategy extends PassportStrategy(Strategy, 'mailchimp') {
+  constructor(
+    @Inject('OAUTH_SECRETS')
+    private readonly oauthSecrets: OauthSecrets,
+  ) {
+    const options = {
+      clientID: oauthSecrets.mailchimp.client_id,
+      clientSecret: oauthSecrets.mailchimp.client_secret,
+      callbackURL: oauthSecrets.mailchimp.redirect_uri,
+      scope: '',
+    };
+    const verify = (
+      accessToken: string,
+      refreshToken: string,
+      profile: any,
+      done,
+    ) => {
+      return done(null, profile, { accessToken, refreshToken });
+    };
+
+    super(options, verify);
+  }
+
+  authenticate(@Req() req, options) {
+    const { customer_id } = req.query;
+    options.state = customer_id;
+    super.authenticate(req, options);
+  }
+}

src/modules/pipelines/pipelines.service.ts

@@ -17,19 +17,14 @@ export class PipelinesService {
   }
 
   async create(createPipelineDto) {
-    try {
-      const createPipelineResponse = await this.pipelineClient.create(
-        createPipelineDto,
-      );
+    const createPipelineResponse = await this.pipelineClient.create(
+      createPipelineDto,
+    );
 
-      const pipeline = objectCamelToSnake(createPipelineResponse);
-      this.adjustPayload(pipeline.pipeline);
+    const pipeline = objectCamelToSnake(createPipelineResponse);
+    this.adjustPayload(pipeline.pipeline);
 
-      return pipeline;
-    } catch (err) {
-      console.log(err);
-      throw new HttpException(err.message, HttpStatus.NOT_FOUND);
-    }
+    return pipeline;
   }
 
   async findOne(data: IIdRequest) {