@pipedream/google_calendar 0.3.3 → 0.3.4

package/sources/event-ended/event-ended.js

@@ -1,68 +0,0 @@
-const _ = require("lodash");
-const googleCalendar = require("../../google_calendar.app.js");
-
-module.exports = {
-  key: "google_calendar-event-ended",
-  name: "Event Ended",
-  description: "Emits when an event ends",
-  version: "0.0.1",
-  dedupe: "unique", // Dedupe events based on the Google Calendar event ID
-  props: {
-    googleCalendar,
-    calendarId: {
-      type: "string",
-      async options() {
-        const calListResp = await this.googleCalendar.calendarList();
-        const calendars = _.get(calListResp, "data.items");
-        if (calendars) {
-          const calendarIds = calendars.map((item) => {
-            return { value: item.id, label: item.summary };
-          });
-          return calendarIds;
-        }
-        return [];
-      },
-    },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 5 * 60,
-      },
-    },
-  },
-  async run(event) {
-    const intervalMs = 1000 * (event.interval_seconds || 300); // fall through to default for manual testing
-    const now = new Date();
-
-    const timeMin = new Date(now.getTime() - intervalMs).toISOString();
-    const timeMax = new Date(now.getTime()).toISOString();
-
-    const config = {
-      calendarId: this.calendarId,
-      timeMax,
-      timeMin,
-      singleEvents: true,
-      orderBy: this.orderBy,
-    };
-    const resp = await this.googleCalendar.getEvents(config);
-
-    const events = _.get(resp.data, "items");
-    if (Array.isArray(events)) {
-      for (const event of events) {
-        const eventEnd = _.get(event, "end.dateTime");
-        const end = new Date(eventEnd);
-        const msFromEnd = now.getTime() - end.getTime();
-        if (eventEnd && msFromEnd > 0 && msFromEnd < intervalMs) {
-          const { summary, id } = event;
-          this.$emit(event, {
-            summary,
-            id,
-            ts: +new Date(event.start.dateTime),
-          });
-        }
-      }
-    } else {
-      console.log("nothing to emit");
-    }
-  },
-};

package/sources/event-search/new-event-search.js

@@ -1,70 +0,0 @@
-const _ = require("lodash");
-const googleCalendar = require("../../google_calendar.app.js");
-
-module.exports = {
-  key: "google_calendar-new-event-search",
-  name: "Event Search",
-  description: "Emit when an event is created that matches a search",
-  version: "0.0.1",
-  dedupe: "unique", // Dedupe events based on the Google Calendar event ID
-  props: {
-    googleCalendar,
-    q: {
-      propDefinition: [googleCalendar, "q"],
-    },
-    calendarId: {
-      type: "string",
-      async options() {
-        const calListResp = await this.googleCalendar.calendarList();
-        const calendars = _.get(calListResp, "data.items");
-        if (calendars) {
-          const calendarIds = calendars.map((item) => {
-            return { value: item.id, label: item.summary };
-          });
-          return calendarIds;
-        }
-        return [];
-      },
-    },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 5 * 60, // five minutes
-      },
-    },
-  },
-  async run(event) {
-    const intervalMs = 1000 * (event.interval_seconds || 300); // fall through to default for manual testing
-    const now = new Date();
-    const past = new Date(now.getTime() - intervalMs);
-
-    const updatedMin = past.toISOString();
-
-    const config = {
-      calendarId: this.calendarId,
-      updatedMin,
-      q: this.q,
-      singleEvents: true,
-      orderBy: "startTime",
-    };
-    const resp = await this.googleCalendar.getEvents(config);
-
-    const events = _.get(resp.data, "items");
-    if (Array.isArray(events)) {
-      for (const event of events) {
-        const created = new Date(event.created);
-        // created in last 5 mins and not cancelled
-        if (created > past && event.status !== "cancelled") {
-          const { summary, id } = event;
-          this.$emit(event, {
-            summary,
-            id,
-            ts: +new Date(event.start.dateTime),
-          });
-        }
-      }
-    } else {
-      console.log("nothing to emit");
-    }
-  },
-};

package/sources/event-start/event-start.js

@@ -1,68 +0,0 @@
-const _ = require("lodash");
-const googleCalendar = require("../../google_calendar.app.js");
-
-module.exports = {
-  key: "google_calendar-event-start",
-  name: "Event Start",
-  description: "Emits a specified time before an event starts",
-  version: "0.0.1",
-  dedupe: "unique", // Dedupe events based on the Google Calendar event ID
-  props: {
-    googleCalendar,
-    calendarId: {
-      type: "string",
-      async options() {
-        const calListResp = await this.googleCalendar.calendarList();
-        const calendars = _.get(calListResp, "data.items");
-        if (calendars) {
-          const calendarIds = calendars.map((item) => {
-            return { value: item.id, label: item.summary };
-          });
-          return calendarIds;
-        }
-        return [];
-      },
-    },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 5 * 60, // five minutes
-      },
-    },
-  },
-  async run(event) {
-    const intervalMs = 1000 * (event.interval_seconds || 300); // fall through to default for manual testing
-    const now = new Date();
-
-    const timeMin = now.toISOString();
-    const timeMax = new Date(now.getTime() + intervalMs).toISOString();
-
-    const config = {
-      calendarId: this.calendarId,
-      timeMax,
-      timeMin,
-      singleEvents: true,
-      orderBy: "startTime",
-    };
-    const resp = await this.googleCalendar.getEvents(config);
-
-    const events = _.get(resp.data, "items");
-    if (Array.isArray(events)) {
-      for (const event of events) {
-        const eventStart = _.get(event, "start.dateTime");
-        start = new Date(eventStart);
-        const msFromStart = start.getTime() - now.getTime();
-        if (eventStart && msFromStart > 0 && msFromStart < intervalMs) {
-          const { summary, id } = event;
-          this.$emit(event, {
-            summary,
-            id,
-            ts: +new Date(event.start.dateTime),
-          });
-        }
-      }
-    } else {
-      console.log("nothing to emit");
-    }
-  },
-};

package/sources/new-calendar/new-calendar.js

@@ -1,50 +0,0 @@
-const _ = require("lodash");
-const googleCalendar = require("../../google_calendar.app.js");
-
-module.exports = {
-  key: "google_calendar-new-calendar",
-  name: "New Calendar",
-  description: "Emit an event when a calendar is created.",
-  version: "0.0.1",
-  props: {
-    db: "$.service.db",
-    googleCalendar,
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 5 * 60,
-      },
-    },
-  },
-  hooks: {
-    async activate() {
-      // get list of calendars
-      const calListResp = await this.googleCalendar.calendarList();
-      const calendars = _.get(calListResp, "data.items");
-      const calendarIds = calendars.map((item) => item.id);
-      this.db.set("calendarIds", calendarIds);
-    },
-    deactivate() {
-      this.db.set("calendarIds", []);
-    },
-  },
-  async run(event) {
-    const previousCalendarIds = this.db.get("calendarIds") || [];
-
-    const calListResp = await this.googleCalendar.calendarList();
-    const calendars = _.get(calListResp, "data.items");
-    const currentCalendarIds = [];
-
-    for (const calendar of calendars) {
-      currentCalendarIds.push(calendar.id);
-      if (!previousCalendarIds.includes(calendar.id)) {
-        const { summary, id } = calendar;
-        this.$emit(calendar, {
-          summary,
-          id,
-        });
-      }
-    }
-    this.db.set("calendarIds", currentCalendarIds);
-  },
-};

package/sources/new-event/new-event.js

@@ -1,65 +0,0 @@
-const _ = require("lodash");
-const googleCalendar = require("../../google_calendar.app.js");
-
-module.exports = {
-  key: "google_calendar-new-event",
-  name: "New Event",
-  description: "Emits when an event is created",
-  version: "0.0.1",
-  dedupe: "unique", // Dedupe events based on the Google Calendar event ID
-  props: {
-    googleCalendar,
-    calendarId: {
-      type: "string",
-      async options() {
-        const calListResp = await this.googleCalendar.calendarList();
-        const calendars = _.get(calListResp, "data.items");
-        if (calendars) {
-          const calendarIds = calendars.map((item) => {
-            return { value: item.id, label: item.summary };
-          });
-          return calendarIds;
-        }
-        return [];
-      },
-    },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 5 * 60, // five minutes
-      },
-    },
-  },
-  async run(event) {
-    const intervalMs = 1000 * (event.interval_seconds || 300); // fall through to default for manual testing
-    const now = new Date();
-    const past = new Date(now.getTime() - intervalMs);
-
-    const updatedMin = past.toISOString();
-
-    const config = {
-      calendarId: this.calendarId,
-      updatedMin,
-      singleEvents: true,
-      orderBy: "startTime",
-    };
-    const resp = await this.googleCalendar.getEvents(config);
-
-    const events = _.get(resp.data, "items");
-    if (Array.isArray(events)) {
-      for (const event of events) {
-        const created = new Date(event.created);
-        if (created > past && event.status !== "cancelled") {
-          const { summary, id } = event;
-          this.$emit(event, {
-            summary,
-            id,
-            ts: +new Date(event.start.dateTime),
-          });
-        }
-      }
-    } else {
-      console.log("nothing to emit");
-    }
-  },
-};

package/sources/new-or-updated-event/new-or-updated-event.js

@@ -1,64 +0,0 @@
-const _ = require("lodash");
-const googleCalendar = require("../../google_calendar.app.js");
-
-module.exports = {
-  key: "google_calendar-new-or-updated-event",
-  name: "New or Updated Event",
-  description: "Emits when an event is created or updated (except when it's cancelled)",
-  version: "0.0.1",
-  dedupe: "unique", // Dedupe events based on the Google Calendar event ID
-  props: {
-    googleCalendar,
-    calendarId: {
-      type: "string",
-      async options() {
-        const calListResp = await this.googleCalendar.calendarList();
-        const calendars = _.get(calListResp, "data.items");
-        if (calendars) {
-          const calendarIds = calendars.map((item) => {
-            return { value: item.id, label: item.summary };
-          });
-          return calendarIds;
-        }
-        return [];
-      },
-    },
-    timer: {
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 5 * 60, // five minutes
-      },
-    },
-  },
-  async run(event) {
-    const intervalMs = 1000 * (event.interval_seconds || 300); // fall through to default for manual testing
-    const now = new Date();
-    const past = new Date(now.getTime() - intervalMs);
-
-    const updatedMin = past.toISOString();
-
-    const config = {
-      calendarId: this.calendarId,
-      updatedMin,
-      singleEvents: true,
-      orderBy: "startTime",
-    };
-    const resp = await this.googleCalendar.getEvents(config);
-
-    const events = _.get(resp.data, "items");
-    if (Array.isArray(events)) {
-      for (const event of events) {
-        if (event.status !== "cancelled") {
-          const { summary, id } = event;
-          this.$emit(event, {
-            summary,
-            id,
-            ts: +new Date(event.start.dateTime),
-          });
-        }
-      }
-    } else {
-      console.log("nothing to emit");
-    }
-  },
-};

package/sources/new-or-updated-event-instant/new-or-updated-event-instant.js

@@ -1,200 +0,0 @@
-const get = require("lodash.get");
-const { v4: uuidv4 } = require("uuid");
-const googleCalendar = require("../../google_calendar.app.js");
-
-module.exports = {
-  key: "google_calendar-new-or-updated-event-instant",
-  name: "New or Updated Event (Instant)",
-  description:
-    "Emits when an event is created or updated (except when it's cancelled)",
-  version: "0.0.3",
-  props: {
-    googleCalendar,
-    db: "$.service.db",
-    calendarId: {
-      type: "string",
-      label: "Calendar",
-      async options() {
-        const calListResp = await this.googleCalendar.calendarList();
-        const calendars = get(calListResp, "data.items");
-        if (calendars) {
-          const calendarIds = calendars.map((item) => {
-            return { value: item.id, label: item.summary };
-          });
-          return calendarIds;
-        }
-        return [];
-      },
-    },
-    newOnly: {
-      label: "New events only?",
-      type: "boolean",
-      description: "Emit new events only, and not updates to existing events",
-    },
-    http: "$.interface.http",
-    timer: {
-      label: "Push notification renewal schedule",
-      description:
-        "The Google Calendar API requires occasional renewal of push notification subscriptions. **This runs in the background, so you should not need to modify this schedule**.",
-      type: "$.interface.timer",
-      default: {
-        intervalSeconds: 60 * 60 * 24,
-      },
-    },
-  },
-  hooks: {
-    async activate() {
-      // make watch request that will hit this http interface
-      const config = {
-        calendarId: this.calendarId,
-        requestBody: {
-          id: uuidv4(),
-          type: "web_hook",
-          address: this.http.endpoint,
-        },
-      };
-      const watchResp = await this.googleCalendar.watch(config);
-      const data = watchResp.data;
-
-      // initial full sync get next sync token
-      const nextSyncToken = await this.googleCalendar.fullSync(this.calendarId);
-
-      this.db.set("nextSyncToken", nextSyncToken);
-      this.db.set("channelId", data.id);
-      this.db.set("resourceId", data.resourceId);
-      this.db.set("expiration", data.expiration);
-    },
-    async deactivate() {
-      const id = this.db.get("channelId");
-      const resourceId = this.db.get("resourceId");
-      if (id && resourceId) {
-        const config = {
-          requestBody: {
-            id,
-            resourceId,
-          },
-        };
-        const stopResp = await this.googleCalendar.stop(config);
-        if (stopResp.status === 204) {
-          console.log("webhook deactivated");
-          this.db.set("nextSyncToken", null);
-          this.db.set("channelId", null);
-          this.db.set("resourceId", null);
-          this.db.set("expiration", null);
-        } else {
-          console.log("there was a problem deactivating the webhook");
-        }
-      }
-    },
-  },
-  async run(event) {
-    // refresh watch
-    if (event.interval_seconds) {
-      // get time
-      const now = new Date();
-      const intervalMs = event.interval_seconds * 1000;
-      // get expriration
-      const expiration = this.db.get("expiration");
-      const expireDate = new Date(parseInt(expiration));
-
-      // if now + interval > expiration, refresh watch
-      if (now.getTime() + intervalMs > expireDate.getTime()) {
-        // do the webhook refresh
-        const config = {
-          calendarId: this.calendarId,
-          requestBody: {
-            id: uuidv4(),
-            type: "web_hook",
-            address: this.http.endpoint,
-          },
-        };
-        const watchResp = await this.googleCalendar.watch(config);
-        const data = watchResp.data;
-        // full sync get next sync token
-        const nextSyncToken = await this.googleCalendar.fullSync(
-          this.calendarId
-        );
-
-        // stop the previous watch
-        const id = this.db.get("channelId");
-        const resourceId = this.db.get("resourceId");
-        if (id && resourceId) {
-          const config = {
-            requestBody: {
-              id,
-              resourceId,
-            },
-          };
-          const stopResp = await this.googleCalendar.stop(config);
-          if (stopResp.status === 204) {
-            console.log("webhook deactivated");
-          } else {
-            console.log("there was a problem deactivating the webhook");
-          }
-        }
-
-        this.db.set("nextSyncToken", nextSyncToken);
-        this.db.set("channelId", data.id);
-        this.db.set("resourceId", data.resourceId);
-        this.db.set("expiration", data.expiration);
-      }
-    } else {
-      // verify channel id
-      const expectedChannelId = this.db.get("channelId");
-      const channelId = get(event, "headers.x-goog-channel-id");
-      if (expectedChannelId != channelId) {
-        console.log(
-          `expected ${expectedChannelId} but got ${channelId}.  Most likely there are multiple webhooks active.`
-        );
-        return;
-      }
-      // check that resource state is exists
-      const state = get(event, "headers.x-goog-resource-state");
-      switch (state) {
-        case "exists":
-          // there's something to emit
-          break;
-        case "not_exists":
-        // TODO handle this?
-        case "sync":
-          console.log("new channel created");
-          return;
-      }
-      // do a listing and then emit everything?
-      const syncToken = this.db.get("nextSyncToken");
-      let nextSyncToken = null;
-      let nextPageToken = null;
-      while (!nextSyncToken) {
-        const listConfig = {
-          calendarId: this.calendarId,
-          syncToken,
-        };
-        listConfig.pageToken = nextPageToken;
-        const syncResp = await this.googleCalendar.list(listConfig);
-        if (syncResp.status == 410) {
-          nextSyncToken = await this.googleCalendar.fullSync(this.calendarId);
-          console.log("sync token is gone, resyncing");
-          break;
-        }
-        nextPageToken = get(syncResp, "data.nextPageToken");
-        nextSyncToken = get(syncResp, "data.nextSyncToken");
-
-        // loop and emit
-        const events = get(syncResp, "data.items");
-        if (Array.isArray(events)) {
-          for (const event of events) {
-            const { summary, id, updated, sequence } = event;
-            if (this.newOnly && sequence != 0) continue;
-            this.$emit(event, {
-              summary,
-              id,
-              ts: +new Date(updated),
-            });
-          }
-        }
-      }
-
-      this.db.set("nextSyncToken", nextSyncToken);
-    }
-  },
-};