Calendly (upgrade) - api v2

src/appmixer/calendly/bundle.json

@@ -1,6 +1,6 @@
 {
     "name": "appmixer.calendly",
-    "version": "2.0.0",
+    "version": "3.0.0",
     "changelog": {
         "1.0.1": [
             "Initial version"
@@ -10,6 +10,12 @@
         ],
         "2.0.0": [
             "Breaking Change: Updated authorization to OAuth2"
+        ],
+        "3.0.0": [
+            "(breaking change): Update components to use Calendly API v2. This change affect both InviteeCreated and InviteeCanceled.",
+            "InviteeCreated and InviteeCanceled have completely new output parameters. It is needed to map all the values from these components again.",
+            "(new) Invitee No Show Created: triggers when an invitee is marked as no-show.",
+            "(new) Invitee No Show Deleted: triggers when an invitee no-show mark is removed."
         ]
     }
 }

src/appmixer/calendly/calendly-commons.js

@@ -1,44 +1,51 @@
 'use strict';
-const request = require('request-promise');
 
 module.exports = {
 
     /**
      * Get request for calendly.
-     * @param {string} token
-     * @param {string} event - should be one of ['invitee.created', 'invitee.canceled']
-     * @param {string} url - webhook callback url that will be registered
+     * @param {Context} context
+     * @param {string} event - should be one of ['invitee.created', 'invitee.canceled', 'invitee_no_show.created', 'invitee_no_show.deleted']
+
      * @returns {*}
      */
-    registerWebhookSubscription(token, event, url) {
+    async registerWebhookSubscription(context, event) {
+        const { accessToken, profileInfo: { resource } } = context.auth;
+        const url = context.getWebhookUrl();
+        context.log({ step: 'registerWebhookSubscription webhookUrl', url });
 
-        return request({
+        const { data } = await context.httpRequest({
             method: 'POST',
-            url: 'https://calendly.com/api/v1/hooks',
+            url: 'https://api.calendly.com/webhook_subscriptions',
             headers: {
-                'Authorization': `Bearer ${token}`
+                'Authorization': `Bearer ${accessToken}`
             },
-            json: true,
-            body: {
+            data: {
                 url: url,
-                events: [event]
+                events: [event],
+                scope: 'user',
+                user: resource.uri,
+                organization: resource.current_organization
             }
         });
+        context.log({ step: 'registerWebhookSubscription response', data });
+        return data.resource;
     },
 
     /**
      * DELETE request for calendly to remove webhook subscription.
-     * @param {string} webhookId
-     * @param {string} token
+     * @param {string} webhookUri
+     * @param {Context} context
      * @returns {*}
      */
-    removeWebhookSubscription(webhookId, token) {
+    async removeWebhookSubscription(webhookUri, context) {
+        const { accessToken } = context.auth;
 
-        return request({
+        await context.httpRequest({
             method: 'DELETE',
-            url: `https://calendly.com/api/v1/hooks/${webhookId}`,
+            url: webhookUri,
             headers: {
-                'Authorization': `Bearer ${token}`
+                'Authorization': `Bearer ${accessToken}`
             }
         });
     }

src/appmixer/calendly/events/InviteeCanceled/InviteeCanceled.js

@@ -1,9 +1,8 @@
 'use strict';
 const commons = require('../../calendly-commons');
-const Promise = require('bluebird');
 
 /**
- * Component which triggers whenever new event is canceled.
+ * Component which triggers whenever an event is canceled.
  * @extends {Component}
  */
 module.exports = {
@@ -24,46 +23,41 @@ module.exports = {
      */
     async receive(context) {
 
-        let data = context.messages.webhook.content.data;
-        if (!data) {
-            return;
+        if (context.messages.webhook) {
+            const { data: webhookData } = context.messages.webhook.content;
+            context.log({ step: 'webhookData received', webhookData });
+
+            if (webhookData) {
+                await context.sendJson(webhookData, 'out');
+            }
+
+            return context.response();
         }
-        await Promise.map([data], data => {
-            data.payload.event['assigned_to'] = data.payload.event['assigned_to'].join(', ');
-            return context.sendJson(data, 'event');
-        });
-        return context.response();
     },
 
     /**
      * Register webhook in Calendly API.
      * @param {Context} context
      * @return {Promise}
      */
-    registerWebhook(context) {
-
-        let url = context.getWebhookUrl();
-
-        return this.unregisterWebhook(context)
-            .then(() => {
-                return commons.registerWebhookSubscription(context.auth.accessToken, 'invitee.canceled', url);
-            }).then(response => {
-                return context.saveState({ webhookId: response.id });
-            });
+    async registerWebhook(context) {
+        await this.unregisterWebhook(context);
+        const response = await commons.registerWebhookSubscription(context, 'invitee.canceled');
+        return context.saveState({ webhookUri: response.uri });
     },
 
     /**
-     * Delete registered webhook. If there is no webhookId in state, do nothing.
+     * Delete registered webhook. If there is no webhookUri in state, do nothing.
      * @param {Context} context
      * @return {Promise}
      */
     unregisterWebhook(context) {
 
-        let webhookId = context.state.webhookId;
-        if (!webhookId) {
-            return Promise.resolve();
+        const { webhookUri } = context.state;
+        if (!webhookUri) {
+            return;
         }
 
-        return commons.removeWebhookSubscription(webhookId, context.auth.accessToken);
+        return commons.removeWebhookSubscription(webhookUri, context);
     }
 };