zoom api + stripe

gistfile1.js

require('dotenv').config({ silent: true });

const cors = require('cors');
const express = require('express');
const axios = require('axios');
const http = require("http");
const jwt = require('jsonwebtoken');
const socketIo = require("socket.io");
const bodyParser = require('body-parser')
const { createProxyMiddleware } = require('http-proxy-middleware');
const index = require("./routes/index");

const app = express();
app.use(cors());

// app.use(cors());
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({ extended: true }));

// SETUP socketIO 
app.use(index);
const server = http.createServer(app);
const io = socketIo(server);
app.io = io;

let interval;
io.on("connection", socket => {
  console.log("New client connected", app.io);
  if (interval) {
    clearInterval(interval);
  }

  interval = setInterval(
    () => console.log('hello'),
    10000
  );
  socket.on("disconnect", () => console.log("Client disconnected"));
});

const zoomPreprocessingMiddlware = (req, res, next) => {
  const payload = {
    iss: process.env.ZOOM_API_KEY,
    exp: ((new Date()).getTime() + 5000)
  };
  const token = jwt.sign(payload, process.env.ZOOM_API_SECRET);
  req.headers['Authorization'] = 'Bearer ' + token;
  next();
}

const googlePreprocessingMiddlware = (req, res, next) => {
  const payload = {
    iss: process.env.ZOOM_API_KEY,
    exp: ((new Date()).getTime() + 5000)
  };
  const token = jwt.sign(payload, process.env.ZOOM_API_SECRET);
  req.headers['Authorization'] = 'Bearer ' + token;
  next();
}

app.get('/zoom', async (req, res , next) => {
  const payload = {
    iss: process.env.ZOOM_API_KEY,
    exp: ((new Date()).getTime() + 5000)
  };
  const token = jwt.sign(payload, process.env.ZOOM_API_SECRET);

  let config = {
    headers: {
      Authorization: 'Bearer ' + token
    }
  }
  console.log(req.query);

  await axios.get(process.env.ZOOM_API_URL + '/' + req.query.endpoint, config)
  .then(data => {
    console.log(data.data);
    res.send(data.data).status(200);
  })
  .catch(err => res.send(err));
});

app.post('/zoom/meeting', async (req, res , next) => {
  const payload = {
    iss: process.env.ZOOM_API_KEY,
    exp: ((new Date()).getTime() + 5000)
  };
  const token = jwt.sign(payload, process.env.ZOOM_API_SECRET);

  let config = {
    headers: {
      Authorization: 'Bearer ' + token
    }
  }

  console.log(req.body);

  await axios.post(process.env.ZOOM_API_URL + '/' + req.query.endpoint + '/' 
    + req.query.userId + '/meetings', req.body, config)
  .then(data => {
    res.send(data.data).status(200);
  })
  .catch(err => res.send(err));
});

app.get('/zoom/meeting', async (req, res , next) => {
  const payload = {
    iss: process.env.ZOOM_API_KEY,
    exp: ((new Date()).getTime() + 5000)
  };
  const token = jwt.sign(payload, process.env.ZOOM_API_SECRET);

  let config = {
    headers: {
      Authorization: 'Bearer ' + token
    }
  }

  console.log(req.body);

  await axios.get(process.env.ZOOM_API_URL + '/' + req.query.endpoint + '/' 
    + req.query.userId + '/meetings', config)
  .then(data => {
    res.send(data.data).status(200);
  })
  .catch(err => res.send(err));
});

app.use('/api/zoom', zoomPreprocessingMiddlware, 
  createProxyMiddleware({ target: process.env.ZOOM_API_URL, changeOrigin: true, pathRewrite: {'^/api/zoom': '/'} }));

// app.use('/api/zoom', zoomPreprocessingMiddlware, 
//   createProxyMiddleware({ target: process.env.ZOOM_API_URL, changeOrigin: true, pathRewrite: {'^/api/zoom': '/'} }));

// app.use('/api/google', googlePreprocessingMiddlware, 
//   createProxyMiddleware({ target: process.env.GOOGLE_API_URL, changeOrigin: true, pathRewrite: {'^/api/google': '/'} }));

// webhook setup for zoom
app.use('/zoom/webhook', (req, res, next) => {
  console.log('body', req.body.event);
  app.io.emit(req.body.event ? 'zoom.webhook': 'zoom.webhook.error', req.body);
  res.send({ response: "I am alive" }).status(200);
});

// webhook setup for stripe
app.post('/stripe/webhook', bodyParser.raw({type: 'application/json'}), (request, response) => {
  let event;

  try {
    event = JSON.parse(request.body);
    console.log('body stripe', event);
  } catch (err) {
    response.status(400).send(`Webhook Error: ${err.message}`);
  }

  // Handle the event
  switch (event.type) {
    case 'payment_intent.succeeded':
      const paymentIntent = event.data.object;
      // Then define and call a method to handle the successful payment intent.
      // handlePaymentIntentSucceeded(paymentIntent);
      break;
    case 'payment_method.attached':
      const paymentMethod = event.data.object;
      // Then define and call a method to handle the successful attachment of a PaymentMethod.
      // handlePaymentMethodAttached(paymentMethod);
      break;
    // ... handle other event types
    default:
      // Unexpected event type
      return response.status(400).end();
  }

  // Return a response to acknowledge receipt of the event
  response.json({received: true});
});

server.listen(process.env.PORT || 5000, () => {
  console.log(`server running on port ${process.env.PORT || 5000}`)
});