투잡할 때 캘린더는 어떻게 최적화?

Calendar.Events.insert({
  summary: 'Personal Busy',
  start: {dateTime: parts[0]},
  end: {dateTime: parts[1]},
  reminders: {useDefault: false},
  extendedProperties: {private: {personalBusySync: '1'}}
}, 'primary');

const MIRROR_SUMMARIES = ['A Busy', 'B Busy', 'Personal Busy'];
// ...
MIRROR_SUMMARIES.indexOf(e.summary) < 0

function probePersonal() {
  const CAL = 'me@personal.com';
  const timeMin = new Date().toISOString();
  const timeMax = new Date(Date.now() + 7 * 864e5).toISOString();

  const fb = Calendar.Freebusy.query({timeMin, timeMax, items: [{id: CAL}]}).calendars[CAL];
  Logger.log('FREEBUSY errors=' + JSON.stringify(fb.errors || null) + ' busy=' + (fb.busy || []).length);

  const r = Calendar.Events.list(CAL, {timeMin, timeMax, singleEvents: true, maxResults: 5});
  Logger.log('EVENTS.LIST count=' + (r.items || []).length + ' firstSummary=' + ((r.items || [])[0] || {}).summary);
}

const TAG_SUFFIX = 'BusySync';

function isMirror(e) {
  const p = (e.extendedProperties || {}).private || {};
  return Object.keys(p).some(k => k.slice(-TAG_SUFFIX.length) === TAG_SUFFIX);
}

// 미러 블록은 제목이 아니라 private extended property 로 식별한다 — 이 태그는 상세 공유된 캘린더를 건너서도 읽히고, 제목과 달리 사용자가 바꾸거나 실제 일정 제목과 충돌하지 않는다.
// 계정별로 다른 곳은 SOURCES 한 곳뿐이고 나머지는 두 프로젝트가 동일하다.
const SOURCES = [
  {id: 'me@company-b.com', tag: 'bBusySync', summary: 'B Busy', freeBusyOnly: false},
  {id: 'me@personal.com', tag: 'personalBusySync', summary: 'Personal Busy', freeBusyOnly: true, untilHour: 22}
];
const TAG_SUFFIX = 'BusySync';
const PAST_DAYS = 7;
const FUTURE_DAYS = 30;

function setup() {
  ScriptApp.getProjectTriggers().forEach(t => ScriptApp.deleteTrigger(t));
  ScriptApp.newTrigger('sync').timeBased().everyMinutes(15).create();
  sync();
}

function sync() {
  const start = new Date();
  start.setHours(0, 0, 0, 0);
  start.setDate(start.getDate() - PAST_DAYS);
  const timeMin = start.toISOString();
  const timeMax = new Date(Date.now() + FUTURE_DAYS * 864e5).toISOString();
  SOURCES.forEach(src => syncOne(src, timeMin, timeMax));
}

function listEvents(calendarId, params) {
  const items = [];
  let pageToken;
  do {
    const resp = Calendar.Events.list(calendarId, Object.assign({maxResults: 2500, singleEvents: true, pageToken: pageToken}, params));
    items.push.apply(items, resp.items || []);
    pageToken = resp.nextPageToken;
  } while (pageToken);
  return items;
}

function isMirror(e) {
  const p = (e.extendedProperties || {}).private || {};
  return Object.keys(p).some(k => k.slice(-TAG_SUFFIX.length) === TAG_SUFFIX);
}

// 개인 일정은 늦은 시간까지 회사 캘린더를 막을 이유가 없다. 여러 날에 걸친 구간도 날마다 잘라 남긴다.
function clipToHour(spans, hour) {
  const out = [];
  for (const s of spans) {
    const day = new Date(s.start);
    day.setHours(0, 0, 0, 0);
    for (; +day < s.end; day.setDate(day.getDate() + 1)) {
      const cut = new Date(day);
      cut.setHours(hour, 0, 0, 0);
      const start = Math.max(s.start, +day), end = Math.min(s.end, +cut);
      if (end > start) out.push({start, end});
    }
  }
  return out;
}

function busySpans(events) {
  return events.filter(e =>
    e.start && e.start.dateTime &&
    e.transparency !== 'transparent' &&
    !(e.attendees || []).some(a => a.self && a.responseStatus === 'declined')
  ).map(e => ({start: +new Date(e.start.dateTime), end: +new Date(e.end.dateTime)}));
}

// 한가함/바쁨 공유는 Freebusy 만 쓸 수 있다. 이 응답은 구간을 병합해 주고 미러도 못 가려내므로 되돌려받지 않는 단방향 소스에만 안전하다.
function sourceBusy(src, timeMin, timeMax) {
  const clip = spans => src.untilHour ? clipToHour(spans, src.untilHour) : spans;
  if (src.freeBusyOnly) {
    const fb = Calendar.Freebusy.query({timeMin: timeMin, timeMax: timeMax, items: [{id: src.id}]}).calendars[src.id];
    if (fb.errors) throw new Error(src.id + ': ' + JSON.stringify(fb.errors));
    return clip((fb.busy || []).map(b => ({start: +new Date(b.start), end: +new Date(b.end)})));
  }
  return clip(busySpans(listEvents(src.id, {timeMin: timeMin, timeMax: timeMax}).filter(e => !isMirror(e))));
}

// 이미 내가 바쁜 구간엔 블록을 또 만들지 않는다. 이 소스가 만든 블록은 제외해야 자기 자신을 지우지 않는다.
function blockers(selfTag, timeMin, timeMax) {
  return busySpans(listEvents('primary', {timeMin: timeMin, timeMax: timeMax})
    .filter(e => !((e.extendedProperties || {}).private || {})[selfTag]));
}

function subtract(spans, blocks) {
  let out = spans;
  for (const b of blocks) {
    const next = [];
    for (const s of out) {
      if (b.end <= s.start || b.start >= s.end) { next.push(s); continue; }
      if (b.start > s.start) next.push({start: s.start, end: b.start});
      if (b.end < s.end) next.push({start: b.end, end: s.end});
    }
    out = next;
  }
  return out.filter(s => s.end > s.start);
}

// 트리거와 수동 실행이 겹치면 같은 블록을 두 번 지우려 한다. 이미 사라진 건 성공으로 친다.
function removeEvent(id) {
  try {
    Calendar.Events.remove('primary', id);
  } catch (err) {
    const msg = String(err);
    if (msg.indexOf('has been deleted') < 0 && msg.indexOf('Not Found') < 0) throw err;
  }
  Utilities.sleep(200);
}

function syncOne(src, timeMin, timeMax) {
  const spans = subtract(sourceBusy(src, timeMin, timeMax), blockers(src.tag, timeMin, timeMax));
  const want = new Set(spans.map(s => new Date(s.start).toISOString() + '/' + new Date(s.end).toISOString()));
  const existing = listEvents('primary', {privateExtendedProperty: src.tag + '=1', timeMin: timeMin, timeMax: timeMax});
  for (const e of existing) {
    const key = new Date(e.start.dateTime).toISOString() + '/' + new Date(e.end.dateTime).toISOString();
    if (want.has(key) && e.summary === src.summary && e.visibility !== 'private') want.delete(key);
    else removeEvent(e.id);
  }
  for (const key of want) {
    const parts = key.split('/');
    const props = {};
    props[src.tag] = '1';
    Calendar.Events.insert({
      summary: src.summary,
      start: {dateTime: parts[0]},
      end: {dateTime: parts[1]},
      reminders: {useDefault: false},
      extendedProperties: {private: props}
    }, 'primary');
    Utilities.sleep(200);
  }
}