Github Integration

server/app.js

@@ -9,18 +9,22 @@ import cors from 'cors';
 import logger from './utils/logger';
 import authorize from './thirdparty/routes/authorize';
 import slackRouter from './thirdparty/routes/slackRouter';
+import githubRouter from './thirdparty/routes/githubRouter';
 import IntegrationService from './controller/IntegrationService';
+import AuthenticationMiddleware from './middlewares/authentication';
 
 dotenv.config();
 
 const app = express();
 const modelDirPath = path.join(__dirname, 'models');
 const routeDirPath = path.join(__dirname, 'routes');
+const publicFolder = path.join(__dirname, '../assets');
 
 app.use(pino());
 app.use(express.json());
 app.use(express.urlencoded({ extended: false }));
-app.use(express.static(path.join(__dirname, 'public')));
+app.use(express.static(publicFolder));
+// app.use('/api/v1', AuthenticationMiddleware);
 app.set('view engine', 'ejs');
 app.set('views', path.join(__dirname, '/thirdparty/views'));
 requireAll(modelDirPath);
@@ -37,6 +41,7 @@ for (const route in routes) {
 // authorize router
 app.use('/', authorize);
 app.use(slackRouter.path, slackRouter.router);
+app.use(githubRouter.path, githubRouter.router);
 
 // catch 404 and forward to error handler
 app.use((req, res, next) => {

server/controller/ActionPerformer.js

@@ -1,15 +1,19 @@
-import SlackActionPerformer from '../thirdparty/controllers/SlackActionPerformer';
-
-const ActionPerformers = {};
-ActionPerformers[SlackActionPerformer.appName] = SlackActionPerformer.performer;
+import eventEmitter from '../lib/eventsLib';
+import slackActionPerformer from '../thirdparty/controllers/SlackActionPerformer';
 
 const ActionPerformer = async (relay, triggerEvent) => {
   const actionsToPerform = relay.participantApps.slice(1);
   for (const action of actionsToPerform) {
     if (action.eventType === 'Action') {
-      ActionPerformer[action.appName](relay, action, triggerEvent);
+      const correspondingActionPerformer = `${action.appName.toLowerCase()}ActionPerformer`;
+      eventEmitter.emit(correspondingActionPerformer, relay, action, triggerEvent);
     }
   }
 };
 
-export default ActionPerformer;
+const exports = {
+  ActionPerformer,
+  slackActionPerformer,
+};
+
+export default exports;

server/controller/AppsController.js

@@ -1,20 +1,57 @@
-import mongoose from 'mongoose';
 import responseLib from '../lib/responseLib';
 import * as actionStatus from '../constants/actionStatus';
+import IntegrationConfig from '../thirdparty/integrationConfig';
+import AuthorizedApps from '../models/AuthorizedApps';
 
-const AppsCollection = mongoose.model('Apps');
+const getApps = (req, res) => {
+  const appsAndEvents = [];
+  for (const [appName, appData] of Object.entries(IntegrationConfig)) {
+    const singleAppDetails = { Trigger: [], Action: [] };
+    singleAppDetails.appName = appName;
+    singleAppDetails.icon = appData.icon_path;
+    for (const event of appData.Events) {
+      singleAppDetails[event.EventType].push(event.EventName);
+    }
+    appsAndEvents.push(singleAppDetails);
+  }
+// const AppsCollection = mongoose.model('Apps');
 
-const createApp = async (req, res) => {
-  console.log(req.body);
-  const createdApp = await AppsCollection.create(req.body);
-  res.send(createdApp);
+  const generatedResponse = responseLib.generateResponse(false, actionStatus.SUCCESS,
+    'Apps and Events', appsAndEvents);
+  res.send(generatedResponse);
+};
+
+const getEventDetails = (req, res) => {
+  let eventDetails;
+  for (const event of IntegrationConfig[req.params.appName].Events) {
+    if (event.EventName === req.query.eventName) {
+      eventDetails = event;
+    }
+  }
+
+  const generatedResponse = responseLib.generateResponse(false, actionStatus.SUCCESS,
+    'Event Details', eventDetails);
+  res.send(generatedResponse);
 };
-const getAllApp = async (req, res) => {
-  const fetchedAppList = await AppsCollection.find({});
-  const generatedResponse = responseLib.generateResponse(false, actionStatus.SUCCESS, 'List Generated', fetchedAppList);
+
+const getAuthorizedAccounts = async (req, res) => {
+  const authorizedAccountsForApp = await AuthorizedApps.find({
+    userId: req.userId,
+    appName: req.params.appName,
+  }).select({
+    _id: 0,
+    appName: 1,
+    email: 1,
+    credentials: 1,
+  });
+
+  const generatedResponse = responseLib.generateResponse(false, actionStatus.SUCCESS,
+    'Authorized accounts for app', authorizedAccountsForApp);
   res.send(generatedResponse);
 };
+
 module.exports = {
-  createApp,
-  getAllApp,
+  getApps,
+  getEventDetails,
+  getAuthorizedAccounts,
 };

server/controller/IntegrationService.js

@@ -2,6 +2,7 @@ import eventEmitter from '../lib/eventsLib';
 import RelayController from './RelayController';
 import IntegrationConfig from '../thirdparty/integrationConfig';
 import WebHookListeners from './WebHookListeners';
+import ActionPerformer from './ActionPerformer';
 
 const installedListeners = [];
 
@@ -21,6 +22,13 @@ const InitializeIntegrationService = async () => {
           installedListeners.push(correspondingListener);
         }
       }
+      if (eventData.EventType === 'Action') {
+        const ActionPerformerName = `${appName.toLowerCase()}ActionPerformer`;
+        if (installedListeners.indexOf(ActionPerformerName) === -1) {
+          eventEmitter.on(ActionPerformerName, ActionPerformer[ActionPerformerName]);
+          installedListeners.push(ActionPerformerName);
+        }
+      }
     }
   }
 };

server/controller/RelayController.js

@@ -1,7 +1,10 @@
+/* eslint-disable no-await-in-loop */
+/* eslint-disable no-underscore-dangle */
 
 import response from '../lib/responseLib';
 import * as actionStatus from '../constants/actionStatus';
 import RelayCollection from '../models/Relays';
+import AuthorizedApps from '../models/AuthorizedApps';
 
 const getCriteria = (criteria) => {
   const filter = {};
@@ -44,14 +47,104 @@ const getRunningRelaysWithTriggerApp = async (appName) => {
 const getRelays = async (req, res) => {
   const filter = getCriteria(req.query);
   // filter.userId = req.userId;
-  const relays = await relayQuery(filter);
+  const relays = await relayQuery(filter, {
+    relayName: 1,
+    isRunning: 1,
+    isDeleted: 1,
+    isPublished: 1,
+    relayId: 1,
+    'participantApps.appName': 1,
+    'participantApps.event': 1,
+    'participantApps.eventType': 1,
+  });
   const generatedResponse = response.generateResponse(false, actionStatus.SUCCESS, 'List of relays', relays);
   res.send(generatedResponse);
 };
 
+const fetchInputsAndAuth = async (app) => {
+  const inputsAndAuth = {};
+  if (app.inputs) {
+    inputsAndAuth.inputs = await InputsCollection.findOne(app.inputs, { _id: 0 });
+  }
+  if (app.authentication) {
+    inputsAndAuth.authentication = await AuthorizedApps.findOne(app.authentication, { _id: 0 });
+  }
+  return inputsAndAuth;
+};
+
+const getSingleRelay = async (req, res) => {
+  const filter = {};
+  filter._id = req.params.relayId; // _id or shortid
+  // filter.userId = req.userId;
+  const singleRelay = await RelayCollection.findOne(filter, {
+    relayName: 1,
+    isRunning: 1,
+    isDeleted: 1,
+    isPublished: 1,
+    participantApps: 1,
+  });
+
+  for (const [index, app] of Object.entries(singleRelay.participantApps)) {
+    const inputsAndAuth = await fetchInputsAndAuth(app);
+    const { appName, event, eventType } = app;
+    singleRelay.participantApps[index] = {
+      appName,
+      event,
+      eventType,
+      ...inputsAndAuth,
+    };
+  }
+
+  const generatedResponse = response.generateResponse(false, actionStatus.SUCCESS, 'Relay details', singleRelay);
+  res.send(generatedResponse);
+};
+
+// validate entries, or get participantApp.authentication wholly instead of id
+const createNewRelay = async (req, res) => {
+  const relayDetails = req.body;
+  // relayDetails.userId = req.userId;
+  const createdRelay = await RelayCollection.create(relayDetails);
+
+  const generatedResponse = response.generateResponse(false, actionStatus.SUCCESS, 'Created relay', createdRelay);
+  res.send(generatedResponse);
+};
+
+const updateExistingRelay = async (req, res) => {
+  const relayIDToBeEdited = {};
+  relayIDToBeEdited._id = req.params.relayId;
+  // relayIDToBeEdited.userId = req.userId;
+  const relayDetailsToBeEdited = req.body;
+
+  const editedRelayDetails = await RelayCollection.findOneAndUpdate(relayIDToBeEdited,
+    relayDetailsToBeEdited);
+
+  const generatedResponse = response.generateResponse(false,
+    actionStatus.SUCCESS, 'Edited relay', editedRelayDetails);
+
+  res.send(generatedResponse);
+};
+
+const moveRelayToTrash = async (req, res) => {
+  const relayIDToBeDeleted = {};
+  relayIDToBeDeleted._id = req.params.relayId;
+  // relayIDToBeDeleted.userId = req.userId;
+
+  const deletedRelayDetails = await RelayCollection.findOneAndUpdate(relayIDToBeDeleted,
+    { isDeleted: false });
+
+  const generatedResponse = response.generateResponse(false,
+    actionStatus.SUCCESS, 'Deleted relay', deletedRelayDetails);
+
+  res.send(generatedResponse);
+};
+
 
 module.exports = {
   getRelays,
+  getSingleRelay,
   getRunningRelays,
   getRunningRelaysWithTriggerApp,
+  createNewRelay,
+  updateExistingRelay,
+  moveRelayToTrash,
 };

server/controller/WebHookListeners.js

@@ -8,7 +8,7 @@ const slackWebHookListener = async (event, authedUsers) => {
 };
 
 const gitWebHookListener = (event) => {
-  console.log(event);
+  // console.log(event);
 };
 
 const exports = {

server/lib/authTokenLib.js

@@ -1,7 +1,7 @@
 import jwt from 'jsonwebtoken';
 import time from './timeLib';
 
-const { JWT_SECRET } = process.env;
+const JWT_SECRET = 'zF9?nCmaZH&?fF9';
 
 const createAuthToken = (userId) => {
   const jwtTokenObject = {
@@ -18,8 +18,23 @@ const verifyAuthToken = (authToken) => new Promise((resolve, reject) => {
     resolve(decoded);
   });
 });
-
+const createGenericAuthToken = (body) => {
+  const jwtTokenObject = {
+    ...body,
+    iat: time.now(),
+  };
+  const jwtToken = jwt.sign(jwtTokenObject, JWT_SECRET, { expiresIn: 3600 });
+  return jwtToken;
+};
+const decodeGenericAuthToken = (authToken) => new Promise((resolve, reject) => {
+  jwt.verify(authToken, JWT_SECRET, (err, decoded) => {
+    if (err) reject(err);
+    resolve(decoded);
+  });
+});
 module.exports = {
   createAuthToken,
   verifyAuthToken,
+  createGenericAuthToken,
+  decodeGenericAuthToken,
 };

server/lib/githubEventLib.js

@@ -0,0 +1,33 @@
+import request from 'request';
+import eventEmitter from './eventsLib';
+import AuthorizedApps from '../models/AuthorizedApps';
+
+eventEmitter.on('Github:Authorize', async (payload) => {
+  // eslint-disable-next-line camelcase
+  const { state, installation_id, code } = payload;
+  const options = {
+    url: 'https://github.com/login/oauth/access_token',
+    method: 'POST',
+    headers: { Accept: 'application/json' },
+    json: {
+      code,
+      client_id: process.env.GITHUB_CLIENT_ID,
+      client_secret: process.env.GITHUB_CLIENT_SECRET,
+    },
+  };
+  request(options, async (err, response, body) => {
+    const authorizedApp = await AuthorizedApps.findOne({ authAppId: state.authAppId });
+    const credentials = [{
+      attributeName: 'access_token',
+      attributeValue: body.access_token,
+    }, {
+      attributeName: 'token_type',
+      attributeValue: body.token_type,
+    }, {
+      attributeName: 'installation_id',
+      attributeValue: installation_id,
+    }];
+    authorizedApp.credentials = credentials;
+    await authorizedApp.save();
+  });
+});

server/middlewares/authentication.js

@@ -19,4 +19,5 @@ const validateAuthentication = async (req, res, next) => {
     res.status(401).send(generatedResponse);
   }
 };
+
 module.exports = validateAuthentication;

server/models/AuthorizedApps.js

@@ -1,19 +1,13 @@
 import mongoose, { Schema } from 'mongoose';
 import shortid from 'shortid';
 
-const AttributeObject = new Schema(
-  {
-    attributeName: String,
-    attributeValue: String,
-  }, { _id: false },
-);
-
 const AuthorizedApps = new Schema({
-  userId: { type: String }, // required:true
+  userId: { type: String, required: true },
   authAppId: { type: String, default: shortid.generate, unique: true },
   appName: { type: String, required: true },
-  credentials: [AttributeObject],
-  version: { type: String, default: '' },
+  email: { type: String }, //  required: true
+  auth_token: { type: String },
+  credentials: { type: Map },
 });
 
 export default mongoose.model('AuthorizedApps', AuthorizedApps);

server/models/RelayHistory.js

@@ -1,7 +1,7 @@
 import mongoose, { Schema } from 'mongoose';
 
 const RelayHistory = new Schema({
-  relayId: { type: String, unique: true },
+  relayId: { type: String },
   status: { type: String },
 }, { timestamps: true });