@pipedream/google_calendar 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pipedream/google_calendar",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "Pipedream Google_calendar Components",
   "main": "google_calendar.app.mjs",
   "keywords": [

package/sources/upcoming-event-alert/upcoming-event-alert.mjs

@@ -1,6 +1,5 @@
 import taskScheduler from "../../../pipedream/sources/new-scheduled-tasks/new-scheduled-tasks.mjs";
 import googleCalendar from "../../google_calendar.app.mjs";
-import { axios } from "@pipedream/platform";
 
 export default {
   key: "google_calendar-upcoming-event-alert",
@@ -8,7 +7,7 @@ export default {
   description: `Emit new event based on a time interval before an upcoming event in the calendar. This source uses Pipedream's Task Scheduler.
     [See the documentation](https://pipedream.com/docs/examples/waiting-to-execute-next-step-of-workflow/#step-1-create-a-task-scheduler-event-source) 
     for more information and instructions for connecting your Pipedream account.`,
-  version: "0.0.5",
+  version: "0.0.6",
   type: "source",
   props: {
     pipedream: taskScheduler.props.pipedream,
@@ -29,45 +28,60 @@ export default {
           calendarId: c.calendarId,
         }),
       ],
+      optional: true,
     },
     time: {
       type: "integer",
       label: "Minutes Before",
       description: "Number of minutes to trigger before the start of the calendar event.",
       min: 0,
+      reloadProps: true,
     },
   },
-  hooks: {
-    async activate() {
-      // workaround - self call run() because selfSubscribe() can't be run on activate or deploy
-      // see selfSubscribe() method in pipedream/sources/new-scheduled-tasks/new-scheduled-tasks.mjs
-      await axios(this, {
-        url: this.http.endpoint,
-        method: "POST",
-        data: {
-          schedule: true,
+  async additionalProps() {
+    const props = {};
+    if (this.time > 0) {
+      props.timer = {
+        type: "$.interface.timer",
+        description: "Poll the API to schedule alerts for any newly created events",
+        default: {
+          intervalSeconds: 60 * this.time,
         },
-      });
-    },
+      };
+    }
+    return props;
+  },
+  hooks: {
     async deactivate() {
-      const id = this._getScheduledEventId();
-      if (id && await this.deleteEvent({
-        body: {
-          id,
-        },
-      })) {
-        console.log("Cancelled scheduled event");
-        this._setScheduledEventId();
+      const ids = this._getScheduledEventIds();
+      if (!ids?.length) {
+        return;
       }
+      for (const id of ids) {
+        if (await this.deleteEvent({
+          body: {
+            id,
+          },
+        })) {
+          console.log("Cancelled scheduled event");
+        }
+      }
+      this._setScheduledEventIds();
     },
   },
   methods: {
     ...taskScheduler.methods,
-    _getScheduledEventId() {
-      return this.db.get("scheduledEventId");
+    _getScheduledEventIds() {
+      return this.db.get("scheduledEventIds");
+    },
+    _setScheduledEventIds(ids) {
+      this.db.set("scheduledEventIds", ids);
     },
-    _setScheduledEventId(id) {
-      this.db.set("scheduledEventId", id);
+    _getScheduledCalendarEventIds() {
+      return this.db.get("scheduledCalendarEventIds");
+    },
+    _setScheduledCalendarEventIds(ids) {
+      this.db.set("scheduledCalendarEventIds", ids);
     },
     _hasDeployed() {
       const result = this.db.get("hasDeployed");
@@ -77,6 +91,32 @@ export default {
     subtractMinutes(date, minutes) {
       return date.getTime() - minutes * 60000;
     },
+    async getCalendarEvents() {
+      const calendarEvents = [];
+      const params = {
+        calendarId: this.calendarId,
+      };
+      if (this.eventId) {
+        const item = await this.googleCalendar.getEvent({
+          ...params,
+          eventId: this.eventId,
+        });
+        calendarEvents.push(item);
+      } else {
+        do {
+          const {
+            data: {
+              items, nextPageToken,
+            },
+          } = await this.googleCalendar.getEvents(params);
+          if (items?.length) {
+            calendarEvents.push(...items);
+          }
+          params.pageToken = nextPageToken;
+        } while (params.pageToken);
+      }
+      return calendarEvents;
+    },
   },
   async run(event) {
     // self subscribe only on the first time
@@ -84,25 +124,37 @@ export default {
       await this.selfSubscribe();
     }
 
+    const scheduledEventIds = this._getScheduledEventIds() || [];
+
     // incoming scheduled event
     if (event.$channel === this.selfChannel()) {
+      const remainingScheduledEventIds = scheduledEventIds.filter((id) => id !== event["$id"]);
+      this._setScheduledEventIds(remainingScheduledEventIds);
       this.emitEvent(event, `Upcoming ${event.summary} event`);
-      this._setScheduledEventId();
       return;
     }
 
-    // received schedule command
-    if (event.body?.schedule) {
-      const calendarEvent = await this.googleCalendar.getEvent({
-        calendarId: this.calendarId,
-        eventId: this.eventId,
-      });
+    // schedule new events
+    const scheduledCalendarEventIds = this._getScheduledCalendarEventIds() || {};
+    const calendarEvents = await this.getCalendarEvents();
 
-      const startTime = new Date(calendarEvent.start.dateTime || calendarEvent.start.date);
+    for (const calendarEvent of calendarEvents) {
+      const startTime = calendarEvent.start
+        ? (new Date(calendarEvent.start.dateTime || calendarEvent.start.date))
+        : null;
+      if (!startTime
+        || startTime.getTime() < Date.now()
+        || scheduledCalendarEventIds[calendarEvent.id])
+      {
+        continue;
+      }
       const later = new Date(this.subtractMinutes(startTime, this.time));
 
       const scheduledEventId = this.emitScheduleEvent(calendarEvent, later);
-      this._setScheduledEventId(scheduledEventId);
+      scheduledEventIds.push(scheduledEventId);
+      scheduledCalendarEventIds[calendarEvent.id] = true;
     }
+    this._setScheduledEventIds(scheduledEventIds);
+    this._setScheduledCalendarEventIds(scheduledCalendarEventIds);
   },
 };