@mcpher/gas-fakes 1.2.28 → 1.2.30

package/src/services/calendarapp/fakecalendareventseries.js

@@ -1,4 +1,6 @@
 import { Proxies } from '../../support/proxies.js';
+import { newFakeEventGuest } from './fakeeventguest.js';
+import * as CalendarEnums from '../enums/calendarenums.js';
 
 export const newFakeCalendarEventSeries = (...args) => {
   return Proxies.guard(new FakeCalendarEventSeries(...args));
@@ -30,6 +32,416 @@ export class FakeCalendarEventSeries {
     return this.__resource.iCalUID || this.__resource.id;
   }
 
+  getTitle() {
+    return this.__resource.summary || '';
+  }
+
+  setTitle(title) {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ summary: title }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  getDescription() {
+    return this.__resource.description || '';
+  }
+
+  setDescription(description) {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ description }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  getLocation() {
+    return this.__resource.location || '';
+  }
+
+  setLocation(location) {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ location }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  // --- Guests ---
+
+  addGuest(email) {
+    this.__checkWriteAccess();
+    // Assuming same guest whitelist logic applies to series
+    this.__checkGuestWhitelist(email);
+
+    const resource = this.__resource;
+    const attendees = resource.attendees || [];
+    if (!attendees.find(a => a.email === email)) {
+      attendees.push({ email });
+      Calendar.Events.patch({ attendees }, this.__calendarId, this.__id, { sendUpdates: 'all' });
+    }
+    return this;
+  }
+
+  removeGuest(email) {
+    this.__checkWriteAccess();
+    const resource = this.__resource;
+    const attendees = resource.attendees || [];
+    const newAttendees = attendees.filter(a => a.email !== email);
+    if (newAttendees.length !== attendees.length) {
+      Calendar.Events.patch({ attendees: newAttendees }, this.__calendarId, this.__id);
+    }
+    return this;
+  }
+
+  getGuestList(includeOwner = false) {
+    const r = this.__resource;
+    if (!r.attendees) return [];
+    return r.attendees.map(a => newFakeEventGuest(a)).filter(g => includeOwner || g.getEmail() !== r.creator.email);
+  }
+
+  getGuestByEmail(email) {
+    const guests = this.getGuestList(true);
+    return guests.find(g => g.getEmail() === email) || null;
+  }
+
+  getCreators() {
+    const r = this.__resource;
+    return r.creator ? [r.creator.email] : [];
+  }
+
+  // --- Reminders ---
+
+  addEmailReminder(minutesBefore) {
+    this.__checkWriteAccess();
+    this.__addReminder('email', minutesBefore);
+    return this;
+  }
+
+  addPopupReminder(minutesBefore) {
+    this.__checkWriteAccess();
+    this.__addReminder('popup', minutesBefore);
+    return this;
+  }
+
+  addSmsReminder(minutesBefore) {
+    this.__checkWriteAccess();
+    this.__addReminder('sms', minutesBefore);
+    return this;
+  }
+
+  __addReminder(method, minutes) {
+    const r = this.__resource;
+    const reminders = r.reminders || { useDefault: true, overrides: [] };
+    if (reminders.useDefault) {
+      reminders.useDefault = false;
+      reminders.overrides = [];
+    }
+    if (!reminders.overrides) reminders.overrides = [];
+    reminders.overrides.push({ method, minutes });
+    Calendar.Events.patch({ reminders }, this.__calendarId, this.__id);
+  }
+
+  getReminders() {
+    const r = this.__resource;
+    if (r.reminders && r.reminders.useDefault) return [];
+    return (r.reminders && r.reminders.overrides) ? r.reminders.overrides.map(o => o.minutes) : [];
+  }
+
+  getEmailReminders() {
+    return this.__getRemindersByMethod('email');
+  }
+
+  getPopupReminders() {
+    return this.__getRemindersByMethod('popup');
+  }
+
+  getSmsReminders() {
+    return this.__getRemindersByMethod('sms');
+  }
+
+  __getRemindersByMethod(method) {
+    const r = this.__resource;
+    if (r.reminders && r.reminders.useDefault) return [];
+    if (!r.reminders || !r.reminders.overrides) return [];
+    return r.reminders.overrides.filter(o => o.method === method).map(o => o.minutes);
+  }
+
+  removeAllReminders() {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ reminders: { useDefault: false, overrides: [] } }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  resetRemindersToDefault() {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ reminders: { useDefault: true } }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  // --- Tags (Extended Properties) ---
+
+  setTag(key, value) {
+    this.__checkWriteAccess();
+    const r = this.__resource;
+    const extendedProperties = r.extendedProperties || { shared: {} };
+    if (!extendedProperties.shared) extendedProperties.shared = {};
+    extendedProperties.shared[key] = value;
+    Calendar.Events.patch({ extendedProperties }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  getTag(key) {
+    const r = this.__resource;
+    return (r.extendedProperties && r.extendedProperties.shared && r.extendedProperties.shared[key]) || null;
+  }
+
+  getAllTagKeys() {
+    const r = this.__resource;
+    return (r.extendedProperties && r.extendedProperties.shared) ? Object.keys(r.extendedProperties.shared) : [];
+  }
+
+  deleteTag(key) {
+    this.__checkWriteAccess();
+    const r = this.__resource;
+    if (r.extendedProperties && r.extendedProperties.shared && r.extendedProperties.shared[key]) {
+        delete r.extendedProperties.shared[key];
+        Calendar.Events.patch({ extendedProperties: r.extendedProperties }, this.__calendarId, this.__id);
+    }
+    return this;
+  }
+
+  // --- Metadata & Permissions ---
+
+  getDateCreated() {
+    return new Date(this.__resource.created);
+  }
+
+  getLastUpdated() {
+    return new Date(this.__resource.updated);
+  }
+
+  isOwnedByMe() {
+    const r = this.__resource;
+    const currentUserEmail = Session.getEffectiveUser().getEmail();
+    return r.creator && r.creator.email === currentUserEmail;
+  }
+
+  getOriginalCalendarId() {
+    return this.__calendarId;
+  }
+
+  getVisibility() {
+    const r = this.__resource;
+    const v = r.visibility || 'default';
+    return CalendarEnums.Visibility[v.toUpperCase()] || CalendarEnums.Visibility.DEFAULT;
+  }
+
+  setVisibility(visibility) {
+    this.__checkWriteAccess();
+    const v = visibility.toString().toLowerCase();
+    Calendar.Events.patch({ visibility: v }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  getColor() {
+    return this.__resource.colorId || '';
+  }
+
+  setColor(color) {
+    this.__checkWriteAccess();
+    // color should be an enum value or a colorId string
+    const colorId = color.toString();
+    Calendar.Events.patch({ colorId }, this.__calendarId, this.__id); 
+    return this;
+  }
+
+  getEventType() {
+    const r = this.__resource;
+    const typeMap = {
+        'default': CalendarEnums.EventType.DEFAULT,
+        'outOfOffice': CalendarEnums.EventType.OUT_OF_OFFICE,
+        'focusTime': CalendarEnums.EventType.FOCUS_TIME,
+        'workingLocation': CalendarEnums.EventType.WORKING_LOCATION
+    };
+    return typeMap[r.eventType] || CalendarEnums.EventType.DEFAULT;
+  }
+
+  getMyStatus() {
+    const r = this.__resource;
+    const me = Session.getEffectiveUser().getEmail();
+    const attendee = (r.attendees || []).find(a => a.email === me);
+    if (!attendee) return CalendarEnums.GuestStatus.NO; // Or maybe INVITED if explicitly?
+    
+    const map = {
+        'accepted': CalendarEnums.GuestStatus.YES,
+        'declined': CalendarEnums.GuestStatus.NO,
+        'tentative': CalendarEnums.GuestStatus.MAYBE,
+        'needsAction': CalendarEnums.GuestStatus.INVITED
+    };
+    return map[attendee.responseStatus] || CalendarEnums.GuestStatus.INVITED;
+  }
+
+  setMyStatus(status) {
+    this.__checkWriteAccess();
+    // In API, patching your own response status is done via events.patch/update usually
+    const me = Session.getEffectiveUser().getEmail();
+    const r = this.__resource;
+    const attendees = r.attendees || [];
+    let attendee = attendees.find(a => a.email === me);
+    
+    // Map Enum to API string
+    const map = {};
+    map[CalendarEnums.GuestStatus.YES] = 'accepted';
+    map[CalendarEnums.GuestStatus.NO] = 'declined';
+    map[CalendarEnums.GuestStatus.MAYBE] = 'tentative';
+    map[CalendarEnums.GuestStatus.INVITED] = 'needsAction';
+    
+    const apiStatus = map[status];
+    if (!apiStatus) return this;
+
+    if (!attendee) {
+        // If I'm not on the list, can I set my status? Maybe adding myself?
+        attendee = { email: me, responseStatus: apiStatus };
+        attendees.push(attendee);
+    } else {
+        attendee.responseStatus = apiStatus;
+    }
+    Calendar.Events.patch({ attendees }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  getTransparency() {
+    const r = this.__resource;
+    const t = r.transparency || 'opaque';
+    return t === 'transparent' ? CalendarEnums.EventTransparency.TRANSPARENT : CalendarEnums.EventTransparency.OPAQUE;
+  }
+
+  setTransparency(transparency) {
+    this.__checkWriteAccess();
+    const t = transparency === CalendarEnums.EventTransparency.TRANSPARENT ? 'transparent' : 'opaque';
+    Calendar.Events.patch({ transparency: t }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  guestsCanInviteOthers() {
+    return !!this.__resource.guestsCanInviteOthers;
+  }
+
+  setGuestsCanInviteOthers(guestsCanInviteOthers) {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ guestsCanInviteOthers }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  guestsCanModify() {
+    return !!this.__resource.guestsCanModify;
+  }
+
+  setGuestsCanModify(guestsCanModify) {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ guestsCanModify }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  guestsCanSeeGuests() {
+    return !!this.__resource.guestsCanSeeGuests;
+  }
+
+  setGuestsCanSeeGuests(guestsCanSeeGuests) {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ guestsCanSeeGuests }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  anyoneCanAddSelf() {
+    return !!this.__resource.anyoneCanAddSelf;
+  }
+
+  setAnyoneCanAddSelf(anyoneCanAddSelf) {
+    this.__checkWriteAccess();
+    Calendar.Events.patch({ anyoneCanAddSelf }, this.__calendarId, this.__id);
+    return this;
+  }
+
+  // --- Recurrence ---
+
+  setRecurrence(recurrence, startTime, endTime) {
+      this.__checkWriteAccess();
+      // This is complex. Recurrence object logic needs to be fully implemented to convert to RRULE.
+      // For now, we will just update start/end time as a placeholder if provided.
+      // Ideally, `recurrence` (EventRecurrence) should provide RRULEs.
+      // TODO: Implement recurrence conversion.
+      const resource = {};
+      if (startTime) resource.start = { dateTime: startTime.toISOString() };
+      if (endTime) resource.end = { dateTime: endTime.toISOString() };
+      
+      // resource.recurrence = [ recurrence.toRRule() ]; // Hypothetical method on FakeEventRecurrence
+      
+      Calendar.Events.patch(resource, this.__calendarId, this.__id);
+      return this;
+  }
+
+  deleteEventSeries() {
+    this.__checkWriteAccess();
+    Calendar.Events.delete(this.__calendarId, this.__id);
+  }
+
+  // --- Helpers (Duplicated from FakeCalendarEvent) ---
+
+  __checkWriteAccess() {
+    this.__checkUsage('write');
+    this.__checkPermission('write');
+  }
+
+  __checkUsage(type) {
+    const serviceName = 'CalendarApp';
+    const behavior = ScriptApp.__behavior;
+    if (behavior && behavior.sandboxMode) {
+        const settings = behavior.sandboxService[serviceName];
+        if (settings) {
+            settings.incrementUsage(type);
+        }
+    }
+  }
+
+  __checkPermission(accessType) {
+    // Basic check relying on FakeCalendar implementation logic or just mimicking it here.
+    // Ideally this logic resides in a shared helper or the CalendarApp/Calendar object.
+    // For now, we assume if we can get the resource, we can try to patch it, and let API handle permissions
+    // UNLESS sandbox mode is on.
+    const behavior = ScriptApp.__behavior;
+    if (!behavior || !behavior.sandboxMode) return;
+
+    // ... (Same logic as FakeCalendarEvent) ...
+    // Simplified: Check if calendar is writable in whitelist.
+    const settings = behavior.sandboxService.CalendarApp;
+    const whitelist = settings && settings.calendarWhitelist;
+    
+    if (!whitelist) throw new Error('Sandbox access denied (no whitelist)');
+
+    // Fetch calendar summary for name check
+    let calendarName = '';
+    try {
+        const cal = Calendar.Calendars.get(this.__calendarId);
+        calendarName = cal.summary;
+    } catch(e) {}
+
+    if (this.__calendarId === 'primary') {
+        const entry = whitelist.find(item => item.name === 'Primary' || item.name === 'primary');
+        if (entry && entry[accessType]) return;
+    }
+    const entry = whitelist.find(item => item.name === calendarName);
+    if (entry && entry[accessType]) return;
+
+    throw new Error(`Sandbox ${accessType} access to calendar ${this.__calendarId} denied`);
+  }
+
+  __checkGuestWhitelist(email) {
+    const behavior = ScriptApp.__behavior;
+    if (!behavior || !behavior.sandboxMode) return;
+    const gmailSettings = behavior.sandboxService.GmailApp;
+    const whitelist = gmailSettings && gmailSettings.emailWhitelist;
+    if (whitelist && !whitelist.includes(email)) {
+        throw new Error(`Adding guest ${email} is denied by Gmail sandbox whitelist`);
+    }
+  }
+
   toString() {
     return 'CalendarEventSeries';
   }

package/src/services/calendarapp/fakeeventguest.js

@@ -0,0 +1,44 @@
+import { Proxies } from '../../support/proxies.js';
+import * as CalendarEnums from '../enums/calendarenums.js';
+
+export const newFakeEventGuest = (...args) => {
+  return Proxies.guard(new FakeEventGuest(...args));
+};
+
+/**
+ * Represents a guest of an event.
+ * @see https://developers.google.com/apps-script/reference/calendar/event-guest
+ */
+export class FakeEventGuest {
+    constructor(resource) {
+        this.__resource = resource;
+    }
+    
+    getEmail() { 
+        return this.__resource.email; 
+    }
+    
+    getName() { 
+        return this.__resource.displayName || ''; 
+    }
+    
+    getGuestStatus() { 
+        const status = this.__resource.responseStatus;
+        // Map API status to Enum
+        const map = {
+            'accepted': CalendarEnums.GuestStatus.YES,
+            'declined': CalendarEnums.GuestStatus.NO,
+            'tentative': CalendarEnums.GuestStatus.MAYBE,
+            'needsAction': CalendarEnums.GuestStatus.INVITED
+        };
+        return map[status] || CalendarEnums.GuestStatus.INVITED;
+    }
+    
+    getAdditionalGuests() { 
+        return this.__resource.additionalGuests || 0; 
+    }
+    
+    toString() { 
+        return 'EventGuest'; 
+    }
+}

package/src/services/calendarapp/fakeeventrecurrence.js

@@ -1,4 +1,5 @@
 import { Proxies } from '../../support/proxies.js';
+import { newFakeRecurrenceRule } from './fakerecurrencerule.js';
 
 export const newFakeEventRecurrence = (...args) => {
   return Proxies.guard(new FakeEventRecurrence(...args));
@@ -10,7 +11,43 @@ export const newFakeEventRecurrence = (...args) => {
  */
 export class FakeEventRecurrence {
   constructor() {
-    // TODO: Implement recurrence rules storage
+    this.rules = [];
+  }
+
+  addDailyExclusion() { return this.__addRule(); }
+  addDailyRule() { return this.__addRule(); }
+  addMonthlyExclusion() { return this.__addRule(); }
+  addMonthlyRule() { return this.__addRule(); }
+  addWeeklyExclusion() { return this.__addRule(); }
+  addWeeklyRule() { return this.__addRule(); }
+  addYearlyExclusion() { return this.__addRule(); }
+  addYearlyRule() { return this.__addRule(); }
+
+  addDate(date) {
+    // RDATE support
+    // This isn't a rule in the same sense, but part of the recurrence definition
+    // For now we store it.
+    if (!this.rDates) this.rDates = [];
+    this.rDates.push(date);
+    return this;
+  }
+
+  addDateExclusion(date) {
+    // EXDATE support
+    if (!this.exDates) this.exDates = [];
+    this.exDates.push(date);
+    return this;
+  }
+
+  setTimeZone(timeZone) {
+    this.timeZone = timeZone;
+    return this;
+  }
+
+  __addRule() {
+    const rule = newFakeRecurrenceRule();
+    this.rules.push(rule);
+    return rule;
   }
 
   toString() {

package/src/services/calendarapp/fakerecurrencerule.js

@@ -0,0 +1,48 @@
+import { Proxies } from '../../support/proxies.js';
+
+export const newFakeRecurrenceRule = (...args) => {
+  return Proxies.guard(new FakeRecurrenceRule(...args));
+};
+
+/**
+ * Represents a recurrence rule for an event series.
+ * @see https://developers.google.com/apps-script/reference/calendar/recurrence-rule
+ */
+export class FakeRecurrenceRule {
+  constructor() {
+    this.rule = {};
+  }
+
+  addDailyExclusion() { return this; }
+  addDailyRule() { return this; }
+  addMonthlyExclusion() { return this; }
+  addMonthlyRule() { return this; }
+  addWeeklyExclusion() { return this; }
+  addWeeklyRule() { return this; }
+  addYearlyExclusion() { return this; }
+  addYearlyRule() { return this; }
+
+  addDate(date) { return this; }
+  addDateExclusion(date) { return this; }
+
+  interval(interval) { return this; }
+  onlyInMonth(month) { return this; }
+  onlyInMonths(months) { return this; }
+  onlyOnMonthDay(day) { return this; }
+  onlyOnMonthDays(days) { return this; }
+  onlyOnMonths(months) { return this; }
+  onlyOnWeek(week) { return this; }
+  onlyOnWeekday(day) { return this; }
+  onlyOnWeekdays(days) { return this; }
+  onlyOnWeeks(weeks) { return this; }
+  onlyOnYearDay(day) { return this; }
+  onlyOnYearDays(days) { return this; }
+  times(times) { return this; }
+  until(date) { return this; }
+  weekStartsOn(day) { return this; }
+  setTimeZone(timeZone) { return this; }
+
+  toString() {
+    return 'RecurrenceRule';
+  }
+}

package/src/services/enums/calendarenums.js

@@ -1,40 +1,45 @@
-import { newFakeGasenum} from "@mcpher/fake-gasenum";
-export const Color = newFakeGasenum([
-  "BLUE",
-  "BROWN",
-  "CHARCOAL",
-  "CHESTNUT",
-  "GRAY",
-  "GREEN",
-  "INDIGO",
-  "LIME",
-  "MUSTARD",
-  "OLIVE",
-  "ORANGE",
-  "PINK",
-  "PLUM",
-  "PURPLE",
-  "RED",
-  "RED_ORANGE",
-  "SEA_BLUE",
-  "SLATE",
-  "TEAL",
-  "TURQOISE",
-  "YELLOW"
-])
-export const EventColor = newFakeGasenum([
-  "BLUE",
-  "CYAN",
-  "GRAY",
-  "GREEN",
-  "MAUVE",
-  "ORANGE",
-  "PALE_BLUE",
-  "PALE_GREEN",
-  "PALE_RED",
-  "RED",
-  "YELLOW"
-])
+import { newFakeGasenum } from "@mcpher/fake-gasenum";
+
+export const Color = newFakeGasenum(
+  {
+    BLUE: "#2952A3",
+    BROWN: "#8D6F47",
+    CHARCOAL: "#4E5D6C",
+    CHESTNUT: "#865A5A",
+    GRAY: "#5A6986",
+    GREEN: "#0D7813",
+    INDIGO: "#5229A3",
+    LIME: "#528800",
+    MUSTARD: "#88880E",
+    OLIVE: "#6E6E41",
+    ORANGE: "#BE6D00",
+    PINK: "#B1365F",
+    PLUM: "#705770",
+    PURPLE: "#7A367A",
+    RED: "#A32929",
+    RED_ORANGE: "#B1440E",
+    SEA_BLUE: "#29527A",
+    SLATE: "#4A716C",
+    TEAL: "#28754E",
+    TURQOISE: "#1B887A",
+    YELLOW: "#AB8B00"
+  })
+
+export const EventColor = newFakeGasenum(
+  {
+    BLUE: "9",
+    CYAN: "7",
+    GRAY: "8",
+    GREEN: "10",
+    MAUVE: "3",
+    ORANGE: "6",
+    PALE_BLUE: "1",
+    PALE_GREEN: "2",
+    PALE_RED: "4",
+    RED: "11",
+    YELLOW: "5"
+  })
+
 export const EventTransparency = newFakeGasenum([
   "OPAQUE",
   "TRANSPARENT"

package/src/services/gmailapp/fakegmailapp.js

@@ -32,11 +32,9 @@ class FakeGmailApp {
       .replace(/\+/g, '-').replace(/\//g, '_');
 
     const draft = Gmail.Users.Drafts.create({ message: { raw: encoded } }, 'me');
-    if (ScriptApp.__behavior.sandboxMode) {
-      if (draft.id) ScriptApp.__behavior.addGmailId(draft.id);
-      if (draft.message && draft.message.id) ScriptApp.__behavior.addGmailId(draft.message.id);
-      if (draft.message && draft.message.threadId) ScriptApp.__behavior.addGmailId(draft.message.threadId);
-    }
+    if (draft.id) ScriptApp.__behavior.addGmailId(draft.id);
+    if (draft.message && draft.message.id) ScriptApp.__behavior.addGmailId(draft.message.id);
+    if (draft.message && draft.message.threadId) ScriptApp.__behavior.addGmailId(draft.message.threadId);
     return newFakeGmailDraft(draft);
   }
 
@@ -61,7 +59,7 @@ class FakeGmailApp {
     }
     const newLabelResource = Gmail.newLabel().setName(name);
     const createdLabelResource = Gmail.Users.Labels.create(newLabelResource, 'me');
-    if (behavior.sandboxMode) behavior.addGmailId(createdLabelResource.id);
+    behavior.addGmailId(createdLabelResource.id);
     return newFakeGmailLabel(createdLabelResource);
   }
 
@@ -456,10 +454,8 @@ class FakeGmailApp {
       .replace(/\+/g, '-').replace(/\//g, '_');
 
     const res = Gmail.Users.Messages.send({ raw: encoded }, 'me');
-    if (behavior.sandboxMode) {
-      if (res.id) behavior.addGmailId(res.id);
-      if (res.threadId) behavior.addGmailId(res.threadId);
-    }
+    if (res.id) behavior.addGmailId(res.id);
+    if (res.threadId) behavior.addGmailId(res.threadId);
     return this;
   }