Feature/discourse integration

backend/src/api/integration/helpers/discourseCreateOrUpdate.ts

@@ -0,0 +1,9 @@
+import Permissions from '../../../security/permissions'
+import IntegrationService from '../../../services/integrationService'
+import PermissionChecker from '../../../services/user/permissionChecker'
+
+export default async (req, res) => {
+  new PermissionChecker(req).validateHas(Permissions.values.tenantEdit)
+  const payload = await new IntegrationService(req).discourseConnectOrUpdate(req.body)
+  await req.responseHandler.success(req, res, payload)
+}

backend/src/api/integration/helpers/discourseTestWebhook.ts

@@ -0,0 +1,15 @@
+import Permissions from '../../../security/permissions'
+import PermissionChecker from '../../../services/user/permissionChecker'
+import IncomingWebhookRepository from '../../../database/repositories/incomingWebhookRepository'
+import SequelizeRepository from '../../../database/repositories/sequelizeRepository'
+
+export default async (req, res) => {
+  new PermissionChecker(req).validateHas(Permissions.values.tenantEdit)
+
+  const options = await SequelizeRepository.getDefaultIRepositoryOptions()
+  const repo = new IncomingWebhookRepository(options)
+
+  const isWebhooksReceived = await repo.checkWebhooksExistForIntegration(req.body.integrationId)
+
+  await req.responseHandler.success(req, res, { isWebhooksReceived })
+}

backend/src/api/integration/helpers/discourseValidator.ts

@@ -0,0 +1,30 @@
+import axios from 'axios'
+import Error400 from '../../../errors/Error400'
+import Permissions from '../../../security/permissions'
+import PermissionChecker from '../../../services/user/permissionChecker'
+
+export default async (req, res) => {
+  new PermissionChecker(req).validateHasAny([
+    Permissions.values.integrationCreate,
+    Permissions.values.integrationEdit,
+  ])
+
+  const { apiKey, apiUsername, forumHostname } = req.body
+
+  if (apiKey && apiUsername && forumHostname) {
+    try {
+      const result = await axios.get(`${forumHostname}/admin/users/list/active.json`, {
+        headers: {
+          'Api-Key': apiKey,
+          'Api-Username': apiUsername,
+        },
+      })
+      if (result.status === 200 && result.data && result.data.length > 0) {
+        return req.responseHandler.success(req, res, result.data)
+      }
+    } catch (e) {
+      return req.responseHandler.error(req, res, new Error400(req.language))
+    }
+  }
+  return req.responseHandler.error(req, res, new Error400(req.language))
+}

backend/src/api/integration/index.ts

@@ -60,6 +60,21 @@ export default (app) => {
     safeWrap(require('./helpers/stackOverflowVolume').default),
   )
 
+  app.post(
+    '/tenant/:tenantId/discourse-connect',
+    safeWrap(require('./helpers/discourseCreateOrUpdate').default),
+  )
+
+  app.post(
+    '/tenant/:tenantId/discourse-validate',
+    safeWrap(require('./helpers/discourseValidator').default),
+  )
+
+  app.post(
+    '/tenant/:tenantId/discourse-test-webhook',
+    safeWrap(require('./helpers/discourseTestWebhook').default),
+  )
+
   if (TWITTER_CONFIG.clientId) {
     /**
      * Using the passport.authenticate this endpoint forces a

backend/src/api/webhooks/discourse.ts

@@ -0,0 +1,89 @@
+import IntegrationRepository from '../../database/repositories/integrationRepository'
+import TenantRepository from '../../database/repositories/tenantRepository'
+import SequelizeRepository from '../../database/repositories/sequelizeRepository'
+import IncomingWebhookRepository from '../../database/repositories/incomingWebhookRepository'
+import { WebhookType } from '../../types/webhooks'
+import { sendNodeWorkerMessage } from '../../serverless/utils/nodeWorkerSQS'
+import { NodeWorkerProcessWebhookMessage } from '../../types/mq/nodeWorkerProcessWebhookMessage'
+import { verifyWebhookSignature } from '../../utils/crypto'
+import { PlatformType } from '../../types/integrationEnums'
+
+export default async (req, res) => {
+  const signature = req.headers['x-discourse-event-signature']
+  const eventId = req.headers['x-discourse-event-id']
+  const eventType = req.headers['x-discourse-event-type']
+  const event = req.headers['x-discourse-event']
+  const data = req.body
+
+  const options = await SequelizeRepository.getDefaultIRepositoryOptions()
+  const tenant = await TenantRepository.findById(req.params.tenantId, options)
+  const optionsWithTenant = await SequelizeRepository.getDefaultIRepositoryOptions(null, tenant)
+  const integration = (await IntegrationRepository.findByPlatform(
+    PlatformType.DISCOURSE,
+    optionsWithTenant,
+  )) as any
+
+  if (integration) {
+    try {
+      if (!signature) {
+        req.log.error({ signature }, 'Discourse Webhook signature header missing!')
+        await req.responseHandler.success(
+          req,
+          res,
+          'Discourse Webhook signature header missing!',
+          200,
+        )
+        return
+      }
+
+      if (
+        !verifyWebhookSignature(JSON.stringify(data), integration.settings.webhookSecret, signature)
+      ) {
+        req.log.error({ signature }, 'Discourse Webhook signature verification failed!')
+        await req.responseHandler.success(
+          req,
+          res,
+          'Discourse Webhook signature verification failed!',
+          200,
+        )
+        return
+      }
+    } catch (error) {
+      req.log.error({ signature, error }, 'Internal error when verifying discourse webhook')
+      await req.responseHandler.success(
+        req,
+        res,
+        'Internal error when verifying discourse webhook',
+        200,
+      )
+      return
+    }
+
+    req.log.info({ integrationId: integration.id }, 'Incoming Discourse Webhook!')
+    const options = await SequelizeRepository.getDefaultIRepositoryOptions()
+    const repo = new IncomingWebhookRepository(options)
+
+    const result = await repo.create({
+      tenantId: integration.tenantId,
+      integrationId: integration.id,
+      type: WebhookType.DISCOURSE,
+      payload: {
+        signature,
+        eventId,
+        eventType,
+        event,
+        data,
+      },
+    })
+
+    await sendNodeWorkerMessage(
+      integration.tenantId,
+      new NodeWorkerProcessWebhookMessage(integration.tenantId, result.id),
+    )
+
+    await req.responseHandler.success(req, res, {}, 204)
+  } else {
+    req.log.error({ tenant }, 'No integration found for incoming Discourse Webhook!')
+    await req.responseHandler.success(req, res, {}, 200)
+  }
+}

backend/src/api/webhooks/index.ts

@@ -4,4 +4,5 @@ export default (app) => {
   app.post(`/github`, safeWrap(require('./github').default))
   app.post(`/stripe`, safeWrap(require('./stripe').default))
   app.post(`/sendgrid`, safeWrap(require('./sendgrid').default))
+  app.post(`/discourse/:tenantId`, safeWrap(require('./discourse').default))
 }

backend/src/database/attributes/member/discourse.ts

@@ -0,0 +1,27 @@
+import { Attribute } from '../attribute'
+import { AttributeType } from '../types'
+import { MemberAttributes, MemberAttributeName } from './enums'
+
+export const DiscourseMemberAttributes: Attribute[] = [
+  {
+    name: MemberAttributes[MemberAttributeName.URL].name,
+    label: MemberAttributes[MemberAttributeName.URL].label,
+    type: AttributeType.URL,
+    canDelete: false,
+    show: true,
+  },
+  {
+    name: MemberAttributes[MemberAttributeName.BIO].name,
+    label: MemberAttributes[MemberAttributeName.BIO].label,
+    type: AttributeType.STRING,
+    canDelete: false,
+    show: true,
+  },
+  {
+    name: MemberAttributes[MemberAttributeName.AVATAR_URL].name,
+    label: MemberAttributes[MemberAttributeName.AVATAR_URL].label,
+    type: AttributeType.URL,
+    canDelete: false,
+    show: false,
+  },
+]

backend/src/database/repositories/incomingWebhookRepository.ts

@@ -232,4 +232,30 @@ export default class IncomingWebhookRepository extends RepositoryBase<
       type: QueryTypes.DELETE,
     })
   }
+
+  async checkWebhooksExistForIntegration(integrationId: string): Promise<boolean> {
+    interface QueryResult {
+      count: number
+    }
+
+    const transaction = this.transaction
+
+    const results: QueryResult[] = await this.seq.query(
+      `
+      select count(*)::int as count
+      from "incomingWebhooks"
+      where "integrationId" = :integrationId
+      limit 1
+    `,
+      {
+        replacements: {
+          integrationId,
+        },
+        type: QueryTypes.SELECT,
+        transaction,
+      },
+    )
+
+    return results.length > 0 && results[0].count > 0
+  }
 }

backend/src/i18n/en.ts

@@ -216,6 +216,7 @@ const en = {
         discord: 'Discord',
         slack: 'Slack',
         hackernews: 'Hacker News',
+        discourse: 'Discourse',
       },
     },
     automation: {

backend/src/serverless/integrations/grid/discordGrid.ts

@@ -10,4 +10,9 @@ export class DiscordGrid {
     score: 6,
     isContribution: true,
   }
+
+  static topic: gridEntry = {
+    score: 8,
+    isContribution: true,
+  }
 }

backend/src/serverless/integrations/grid/discourseGrid.ts

@@ -0,0 +1,23 @@
+import { gridEntry } from './grid'
+
+export class DiscourseGrid {
+  static create_topic: gridEntry = {
+    score: 8,
+    isContribution: true,
+  }
+
+  static message_in_topic: gridEntry = {
+    score: 6,
+    isContribution: true,
+  }
+
+  static join: gridEntry = {
+    score: 3,
+    isContribution: false,
+  }
+
+  static like: gridEntry = {
+    score: 1,
+    isContribution: false,
+  }
+}

backend/src/serverless/integrations/services/integrationProcessor.ts

@@ -19,6 +19,7 @@ import { SlackIntegrationService } from './integrations/slackIntegrationService'
 import { StackOverlflowIntegrationService } from './integrations/stackOverflowIntegrationService'
 import { TwitterIntegrationService } from './integrations/twitterIntegrationService'
 import { TwitterReachIntegrationService } from './integrations/twitterReachIntegrationService'
+import { DiscourseIntegrationService } from './integrations/discourseIntegrationService'
 import { IntegrationServiceBase } from './integrationServiceBase'
 import { IntegrationTickProcessor } from './integrationTickProcessor'
 import { WebhookProcessor } from './webhookProcessor'
@@ -45,6 +46,7 @@ export class IntegrationProcessor extends LoggingBase {
       new SlackIntegrationService(),
       new GithubIntegrationService(),
       new StackOverlflowIntegrationService(),
+      new DiscourseIntegrationService(),
     ]
 
     // add premium integrations