@guayaba/workflow-piece-google-calendar 0.9.1

package/src/lib/actions/create-event.ts

@@ -0,0 +1,163 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { googleCalendarCommon, googleCalendarAuth, createGoogleClient } from '../common';
+import dayjs from 'dayjs';
+import { google } from 'googleapis';
+import { randomUUID } from 'crypto';
+
+export const createEvent = createAction({
+  auth: googleCalendarAuth,
+  name: 'create_google_calendar_event',
+  description: 'Add Event',
+  displayName: 'Create Event',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    title: Property.ShortText({
+      displayName: 'Title of the event',
+      required: true,
+    }),
+    start_date_time: Property.DateTime({
+      displayName: 'Start date time of the event',
+      required: true,
+    }),
+    end_date_time: Property.DateTime({
+      displayName: 'End date time of the event',
+      description: "By default it'll be 30 min post start time",
+      required: false,
+    }),
+    location: Property.ShortText({
+      displayName: 'Location',
+      required: false,
+    }),
+    /*attachment: Property.ShortText({
+      displayName: 'Attachment',
+      description: 'URL of the file to be attached',
+      required: false,
+    }),*/
+    description: Property.LongText({
+      displayName: 'Description',
+      description: 'Description of the event. You can use HTML tags here.',
+      required: false,
+    }),
+    colorId: googleCalendarCommon.colorId,
+    attendees: Property.Array({
+      displayName: 'Attendees',
+      description: 'Emails of the attendees (guests)',
+      required: false,
+    }),
+    guests_can_modify: Property.Checkbox({
+      displayName: 'Guests can modify',
+      defaultValue: false,
+      required: false,
+    }),
+    guests_can_invite_others: Property.Checkbox({
+      displayName: 'Guests can invite others',
+      defaultValue: false,
+      required: false,
+    }),
+    guests_can_see_other_guests: Property.Checkbox({
+      displayName: 'Guests can see other guests',
+      defaultValue: false,
+      required: false,
+    }),
+    send_notifications: Property.StaticDropdown({
+      displayName: 'Send Notifications',
+      defaultValue: 'all',
+      options: {
+        options: [
+          { label: 'Yes, to everyone', value: 'all' },
+          {
+            label: 'To non-Google Calendar guests only',
+            value: 'externalOnly',
+          },
+          { label: 'To no one', value: 'none' },
+        ],
+      },
+      required: true,
+    }),
+    create_meet_link: Property.Checkbox({
+      displayName: 'Create Google Meet Link',
+      description: 'Automatically create a Google Meet video conference link for this event',
+      defaultValue: false,
+      required: false,
+    }),
+  },
+  async run(configValue) {
+    // docs: https://developers.google.com/calendar/api/v3/reference/events/insert
+    const {
+      calendar_id: calendarId,
+      title: summary,
+      start_date_time,
+      end_date_time,
+      location,
+      description,
+      colorId,
+      guests_can_modify: guestsCanModify,
+      guests_can_invite_others: guestsCanInviteOthers,
+      guests_can_see_other_guests: guestsCanSeeOtherGuests,
+      create_meet_link: createMeetLink,
+    } = configValue.propsValue;
+
+    const start = {
+      dateTime: dayjs(start_date_time).format('YYYY-MM-DDTHH:mm:ss.sssZ'),
+    };
+    const endTime = end_date_time
+      ? end_date_time
+      : dayjs(start_date_time).add(30, 'm');
+    const end = {
+      dateTime: dayjs(endTime).format('YYYY-MM-DDTHH:mm:ss.sssZ'),
+    };
+
+    /*const attachment = {
+      fileUrl: configValue.propsValue.attachment,
+    };*/
+
+    const attendeesArray = configValue.propsValue.attendees as string[];
+
+    const sendNotifications = configValue.propsValue.send_notifications;
+
+    const attendeesObject = [];
+    if (attendeesArray) {
+      for (const attendee of attendeesArray) {
+        attendeesObject.push({ email: attendee });
+      }
+    }
+
+    const authClient = await createGoogleClient(configValue.auth);
+
+    const calendar = google.calendar({ version: 'v3', auth: authClient });
+
+    const requestBody: any = {
+      summary,
+      start,
+      end,
+      colorId,
+      //attachments: configValue.propsValue.attachment ? [attachment] : [],
+      location: location ?? '',
+      description: description ?? '',
+      attendees: attendeesObject,
+      guestsCanInviteOthers,
+      guestsCanModify,
+      guestsCanSeeOtherGuests,
+    };
+
+    if (createMeetLink) {
+      requestBody.conferenceData = {
+        createRequest: {
+          conferenceSolutionKey: {
+            type: 'hangoutsMeet',
+          },
+          requestId: randomUUID(),
+        },
+      };
+    }
+
+    const response = await calendar.events.insert({
+      calendarId,
+      sendUpdates: sendNotifications,
+      conferenceDataVersion: createMeetLink ? 1 : 0,
+      requestBody,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/actions/create-quick-event.ts

@@ -0,0 +1,66 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+  HttpRequest,
+  HttpMethod,
+  AuthenticationType,
+  httpClient,
+} from '@guayaba/workflows-common';
+import { googleCalendarCommon, googleCalendarAuth, getAccessToken } from '../common';
+
+export const createQuickCalendarEvent = createAction({
+  auth: googleCalendarAuth,
+  name: 'create_quick_event',
+  description: 'Add Quick Calendar Event',
+  displayName: 'Create Quick Event',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    text: Property.LongText({
+      displayName: 'Summary',
+      description: 'The text describing the event to be created',
+      required: true,
+    }),
+    send_updates: Property.StaticDropdown<string>({
+      displayName: 'Send Updates',
+      description:
+        'Guests who should receive notifications about the creation of the new event.',
+      required: false,
+      options: {
+        disabled: false,
+        options: [
+          {
+            label: 'All',
+            value: 'all',
+          },
+          {
+            label: 'External Only',
+            value: 'externalOnly',
+          },
+          {
+            label: 'none',
+            value: 'none',
+          },
+        ],
+      },
+    }),
+  },
+  async run(configValue) {
+    // docs: https://developers.google.com/calendar/api/v3/reference/events/quickAdd
+    const calendarId = configValue.propsValue['calendar_id'];
+    const url = `${googleCalendarCommon.baseUrl}/calendars/${calendarId}/events/quickAdd`;
+    const qParams: Record<string, string> = {
+      text: configValue.propsValue['text'],
+      sendUpdates: configValue.propsValue['send_updates'] || 'none',
+    };
+    const request: HttpRequest<Record<string, unknown>> = {
+      method: HttpMethod.POST,
+      url,
+      body: {},
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: await getAccessToken(configValue.auth),
+      },
+      queryParams: qParams,
+    };
+    return await httpClient.sendRequest(request);
+  },
+});

package/src/lib/actions/delete-event.action.ts

@@ -0,0 +1,32 @@
+import { Property, createAction } from '@guayaba/workflows-framework';
+import { google } from 'googleapis';
+import { googleCalendarCommon, googleCalendarAuth, createGoogleClient } from '../common';
+
+export const deleteEventAction = createAction({
+  displayName: 'Delete Event',
+  auth: googleCalendarAuth,
+  name: 'delete_event',
+  description: 'Deletes an event from Google Calendar.',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    eventId: Property.ShortText({
+      displayName: 'Event ID',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const authClient = await createGoogleClient(context.auth);
+
+    const calendarId = context.propsValue.calendar_id;
+    const eventId = context.propsValue.eventId;
+
+    const calendar = google.calendar({ version: 'v3', auth: authClient });
+
+    const response = await calendar.events.delete({
+      calendarId,
+      eventId,
+    });
+
+    return response.data;
+  },
+});

package/src/lib/actions/find-busy-free-periods.ts

@@ -0,0 +1,97 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import { HttpRequest, HttpMethod, AuthenticationType, httpClient } from '@guayaba/workflows-common';
+import { googleCalendarCommon, googleCalendarAuth, getAccessToken, GoogleCalendarAuthValue } from '../common';
+import { getCalendars } from '../common/helper';
+import dayjs from 'dayjs';
+
+
+interface FreeBusyResponse {
+  kind: 'calendar#freeBusy';
+  timeMin: string;
+  timeMax: string;
+  calendars: {
+    [calendarId: string]: {
+      busy: {
+        start: string;
+        end: string;
+      }[];
+      errors?: {
+        domain: string;
+        reason: string;
+      }[];
+    };
+  };
+}
+
+export const findFreeBusy = createAction({
+  auth: googleCalendarAuth,
+  name: 'google_calendar_find_busy_free_periods',
+  displayName: 'Find Busy/Free Periods in Calendar',
+  description: 'Finds free/busy calendar details from Google Calendar.',
+  props: {
+    calendar_ids: Property.MultiSelectDropdown({
+      auth: googleCalendarAuth,
+      displayName: 'Calendars',
+      description: 'Select the calendars to check for busy periods.',
+      required: true,
+      refreshers: [],
+      options: async ({ auth }) => {
+        if (!auth) {
+          return {
+            disabled: true,
+            placeholder: 'Connect your account first',
+            options: [],
+          };
+        }
+        const authProp = auth as GoogleCalendarAuthValue;
+        const calendars = await getCalendars(authProp);
+        return {
+          disabled: false,
+          options: calendars.map((calendar) => {
+            return {
+              label: calendar.summary,
+              value: calendar.id,
+            };
+          }),
+        };
+      },
+    }),
+    start_date: Property.DateTime({
+      displayName: 'Start Time',
+      description: 'The start of the time range to check.',
+      required: true,
+    }),
+    end_date: Property.DateTime({
+      displayName: 'End Time',
+      description: 'The end of the time range to check.',
+      required: true,
+    }),
+  },
+  async run(context) {
+    const { calendar_ids, start_date, end_date } = context.propsValue;
+    const access_token = await getAccessToken(context.auth);
+
+    const requestBody = {
+      
+      timeMin: dayjs(start_date).toISOString(),
+      timeMax: dayjs(end_date).toISOString(),
+      
+      items: calendar_ids.map((id) => ({ id })),
+    };
+
+    const request: HttpRequest = {
+      method: HttpMethod.POST,
+      url: `${googleCalendarCommon.baseUrl}/freeBusy`,
+      body: requestBody,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: access_token,
+      },
+    };
+
+    const response = await httpClient.sendRequest<FreeBusyResponse>(request);
+    
+    
+    return response.body;
+  },
+});

package/src/lib/actions/get-event-by-id.ts

@@ -0,0 +1,123 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+  HttpRequest,
+  HttpMethod,
+  AuthenticationType,
+  httpClient,
+} from '@guayaba/workflows-common';
+import { googleCalendarCommon, googleCalendarAuth, getAccessToken } from '../common';
+import { GoogleCalendarEvent } from '../common/types';
+
+export const getEventById = createAction({
+  auth: googleCalendarAuth,
+  name: 'google_calendar_get_event_by_id',
+  displayName: 'Get Event by ID',
+  description: 'Fetch event details by its unique ID from Google Calendar.',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown(),
+    event_id: Property.ShortText({
+      displayName: 'Event ID',
+      description:
+        'The unique ID of the event (e.g., "abc123def456"). You can find this in the event URL or from other calendar actions.',
+      required: true,
+    }),
+    max_attendees: Property.Number({
+      displayName: 'Max Attendees',
+      description:
+        'Maximum number of attendees to include in the response. If there are more attendees, only the participant is returned.',
+      required: false,
+    }),
+    time_zone: Property.ShortText({
+      displayName: 'Time Zone',
+      description:
+        'Time zone for the response (e.g., "America/New_York", "Europe/London"). Defaults to the calendar\'s time zone if not specified.',
+      required: false,
+    }),
+  },
+  async run(context) {
+    const {
+      calendar_id: calendarId,
+      event_id: eventId,
+      max_attendees: maxAttendees,
+      time_zone: timeZone,
+    } = context.propsValue;
+    const token = await getAccessToken(context.auth);
+
+    if (
+      !calendarId ||
+      typeof calendarId !== 'string' ||
+      calendarId.trim().length === 0
+    ) {
+      throw new Error('Calendar ID is required');
+    }
+
+    if (
+      !eventId ||
+      typeof eventId !== 'string' ||
+      eventId.trim().length === 0
+    ) {
+      throw new Error('Event ID cannot be empty');
+    }
+
+    if (eventId.length < 5 || eventId.length > 1024) {
+      throw new Error('Event ID must be between 5 and 1024 characters');
+    }
+
+    const queryParams: Record<string, string> = {};
+
+    if (maxAttendees !== undefined && maxAttendees > 0) {
+      queryParams.maxAttendees = maxAttendees.toString();
+    }
+
+    if (
+      timeZone &&
+      typeof timeZone === 'string' &&
+      timeZone.trim().length > 0
+    ) {
+      queryParams.timeZone = timeZone.trim();
+    }
+
+    const url = `${googleCalendarCommon.baseUrl}/calendars/${encodeURIComponent(
+      calendarId.trim()
+    )}/events/${encodeURIComponent(eventId.trim())}`;
+
+    const request: HttpRequest = {
+      method: HttpMethod.GET,
+      url: url,
+      queryParams: queryParams,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token: token,
+      },
+    };
+
+    try {
+      const response = await httpClient.sendRequest<GoogleCalendarEvent>(
+        request
+      );
+      return response.body;
+    } catch (error: any) {
+      if (error.response?.status === 404) {
+        throw new Error(
+          `Event with ID "${eventId}" not found in calendar "${calendarId}". Please verify the event ID and calendar selection.`
+        );
+      } else if (error.response?.status === 403) {
+        throw new Error(
+          `Access denied to event "${eventId}" in calendar "${calendarId}". Please check your permissions.`
+        );
+      } else if (error.response?.status === 400) {
+        throw new Error(
+          `Invalid request parameters. Please check the event ID format and other parameters.`
+        );
+      } else if (error.response?.status === 401) {
+        throw new Error(
+          'Authentication failed. Please reconnect your Google Calendar account.'
+        );
+      } else {
+        throw new Error(
+          `Failed to fetch event: ${error.message || 'Unknown error occurred'}`
+        );
+      }
+    }
+  },
+});

package/src/lib/actions/get-events.ts

@@ -0,0 +1,111 @@
+import { createAction, Property } from '@guayaba/workflows-framework';
+import {
+  HttpRequest,
+  HttpMethod,
+  AuthenticationType,
+  httpClient,
+} from '@guayaba/workflows-common';
+import { googleCalendarCommon, googleCalendarAuth, getAccessToken } from '../common';
+import dayjs from 'dayjs';
+
+export const getEvents = createAction({
+  auth: googleCalendarAuth,
+  name: 'google_calendar_get_events',
+  description: 'Get Events',
+  displayName: 'Get all Events',
+  props: {
+    calendar_id: googleCalendarCommon.calendarDropdown('writer'),
+    event_types: Property.StaticMultiSelectDropdown({
+      displayName: 'Event types',
+      description: 'Select event types',
+      required: true,
+      defaultValue: ['default', 'focusTime', 'outOfOffice'],
+      options: {
+        options: [
+          {
+            label: 'Default',
+            value: 'default',
+          },
+          {
+            label: 'Out Of Office',
+            value: 'outOfOffice',
+          },
+          {
+            label: 'Focus Time',
+            value: 'focusTime',
+          },
+          {
+            label: 'Working Location',
+            value: 'workingLocation',
+          },
+        ],
+      },
+    }),
+    search: Property.ShortText({
+      displayName: 'Search Term',
+      required: false,
+    }),
+    start_date: Property.DateTime({
+      displayName: 'Date from',
+      required: false,
+    }),
+    end_date: Property.DateTime({
+      displayName: 'Date to',
+      required: false,
+    }),
+    singleEvents: Property.Checkbox({
+			displayName: 'Expand Recurring Event?',
+      description: "Whether to expand recurring events into instances and only return single one-off events and instances of recurring events, but not the underlying recurring events themselves.",
+			required: true,
+			defaultValue: false,
+		}),
+  },
+  async run(configValue) {
+    // docs: https://developers.google.com/calendar/api/v3/reference/events/list
+    const {
+      calendar_id: calendarId,
+      start_date,
+      end_date,
+      search,
+      event_types,
+      singleEvents,
+    } = configValue.propsValue;
+    const token = await getAccessToken(configValue.auth);
+    const queryParams: Record<string, string> = { showDeleted: 'false' };
+    let url = `${googleCalendarCommon.baseUrl}/calendars/${calendarId}/events`;
+
+    if(singleEvents !== null) {
+      queryParams['singleEvents'] = singleEvents ? 'true' : 'false';
+    }
+
+    if (search) {
+      queryParams['q'] = `"${search}"`;
+    }
+
+    // date range
+    if (start_date) {
+      queryParams['timeMin'] = dayjs(start_date).format(
+        'YYYY-MM-DDTHH:mm:ss.sssZ'
+      );
+    }
+    if (start_date && end_date) {
+      queryParams['timeMax'] = dayjs(end_date).format(
+        'YYYY-MM-DDTHH:mm:ss.sssZ'
+      );
+    }
+    // filter by event type
+    if (event_types.length > 0) {
+      url += `?${event_types.map((type) => `eventTypes=${type}`).join('&')}`;
+    }
+    const request: HttpRequest<Record<string, unknown>> = {
+      method: HttpMethod.GET,
+      url,
+      queryParams,
+      authentication: {
+        type: AuthenticationType.BEARER_TOKEN,
+        token,
+      },
+    };
+    return await httpClient.sendRequest(request);
+  },
+});