【GAS公開】ANA PayをZaimに自動連携｜利用通知から自動記帳・二重登録対策

/**
 * ANA Pay → Zaim 自動記帳
 *
 * 【通常運用】
 * ・6時間おきのトリガーを想定
 * ・直近1日分のANA Pay通知を確認
 * ・未処理通知は1回最大20件まで
 *
 * 【初回・手動実行】
 * ・直近7日分を確認
 * ・最大100件まで処理
 *
 * 【記帳ルール】
 * ・ANA Pay決済：支出として登録（店舗名も自動登録）
 * ・ANA Payチャージ：収入として仮登録
 *   （チャージ元口座の自動連携後、手動で振替へ変更）
 *
 * 【重複防止】
 * ・決済：利用日時＋金額＋店舗名＋通貨を主判定
 * ・チャージ：GmailメッセージIDを主判定
 * ・内部IDはZaimのメモ欄には表示しない
 */

const SCRIPT_PROPS = PropertiesService.getScriptProperties();
const USER_PROPS = PropertiesService.getUserProperties();

const CONSUMER_KEY = SCRIPT_PROPS.getProperty("ZAIM_CONSUMER_ID");
const CONSUMER_SECRET = SCRIPT_PROPS.getProperty("ZAIM_CONSUMER_SECRET");

const ANA_PAY_SENDER = "payinfo@121.ana.co.jp";

// 初回・手動実行は直近7日、通常実行は直近1日を確認
const INITIAL_LOOKBACK_DAYS = 7;
const NORMAL_LOOKBACK_DAYS = 1;

// 1回の実行で処理する未処理通知の上限
const NORMAL_MAX_NEW_MESSAGES = 20;
const WIDE_MAX_NEW_MESSAGES = 100;

// Gmail検索は50スレッドずつページング
const GMAIL_PAGE_SIZE = 50;

// 想定外に大量のメールが存在した場合の検索安全弁
const NORMAL_MAX_SCANNED_MESSAGES = 100;
const WIDE_MAX_SCANNED_MESSAGES = 300;

// 通常実行が24時間以上成功していない場合は手動実行を案内
const STALE_NORMAL_HOURS = 24;

const INITIALIZED_KEY = "ANAPAY_INITIALIZED";
const LAST_SUCCESS_AT_KEY = "ANAPAY_LAST_SUCCESS_AT";

// 処理済みトークンは日ごとに保存し、14日より古いものを削除
const DONE_BUCKET_PREFIX = "ANAPAY_DONE_";
const DONE_TOKEN_RETENTION_DAYS = 14;

// 1実行中のProperties読み込みを減らすためのキャッシュ
const DONE_BUCKET_CACHE = {};

function getService() {
  return OAuth1.createService("Zaim")
    .setAccessTokenUrl("https://api.zaim.net/v2/auth/access")
    .setRequestTokenUrl("https://api.zaim.net/v2/auth/request")
    .setAuthorizationUrl("https://auth.zaim.net/users/auth")
    .setConsumerKey(CONSUMER_KEY)
    .setConsumerSecret(CONSUMER_SECRET)
    .setCallbackFunction("authCallback")
    .setPropertyStore(USER_PROPS);
}

function authCallback(request) {
  const service = getService();
  const authorized = service.handleCallback(request);

  return HtmlService.createHtmlOutput(
    authorized
      ? "Zaimの認証が完了しました！このタブを閉じてください。"
      : "認証に失敗しました。"
  );
}

// Zaimの口座・カテゴリー・ジャンルID確認
function checkZaimIds() {
  const service = getService();

  if (!service.hasAccess()) {
    Logger.log("まず anaPayToZaim を実行してZaim認証を完了してください。");
    return;
  }

  Logger.log("=== 口座(入出金元) ID一覧 ===");
  const accounts = JSON.parse(
    service.fetch("https://api.zaim.net/v2/home/account").getContentText()
  ).accounts;

  accounts.forEach(function(account) {
    Logger.log(account.name + ": " + account.id);
  });

  const categoryMap = {};
  const categories = JSON.parse(
    service.fetch("https://api.zaim.net/v2/home/category").getContentText()
  ).categories;

  Logger.log("=== 支出カテゴリー ID一覧 ===");
  categories.forEach(function(category) {
    categoryMap[category.id] = category.name;
    if (category.mode === "payment") {
      Logger.log(category.name + ": " + category.id);
    }
  });

  Logger.log("=== 収入カテゴリー ID一覧 ===");
  categories.forEach(function(category) {
    if (category.mode === "income") {
      Logger.log(category.name + ": " + category.id);
    }
  });

  Logger.log("=== ジャンル(内訳) ID一覧 ===");
  try {
    const genres = JSON.parse(
      service.fetch("https://api.zaim.net/v2/home/genre").getContentText()
    ).genres;

    genres.forEach(function(genre) {
      const parentCategoryName =
        categoryMap[genre.category_id] || "不明なカテゴリ";
      Logger.log(
        "[" + parentCategoryName + "] " + genre.name + ": " + genre.id
      );
    });
  } catch (e) {
    Logger.log("ジャンル一覧の取得に失敗しました: " + e.message);
  }
}

/**
 * 通常の自動実行用。
 * 初回だけは自動的に直近7日・最大100件で実行する。
 * 2回目以降は直近1日・最大20件。
 */
function anaPayToZaim() {
  const initialized = USER_PROPS.getProperty(INITIALIZED_KEY) === "1";

  if (!initialized) {
    runAnaPaySync_(
      "initial",
      INITIAL_LOOKBACK_DAYS,
      WIDE_MAX_NEW_MESSAGES,
      WIDE_MAX_SCANNED_MESSAGES
    );
    return;
  }

  const lastSuccessAt = Number(
    USER_PROPS.getProperty(LAST_SUCCESS_AT_KEY) || 0
  );

  if (
    lastSuccessAt &&
    Date.now() - lastSuccessAt > STALE_NORMAL_HOURS * 60 * 60 * 1000
  ) {
    throw new Error(
      "ANA Payの自動登録を保留しました。前回の正常終了から24時間以上経過しているため、" +
      "通常の1日検索では取りこぼす可能性があります。今回はZaimへ1件も登録していません。" +
      "Google Apps Scriptを開き、関数 anaPayToZaimManual を1回実行してください。"
    );
  }

  runAnaPaySync_(
    "normal",
    NORMAL_LOOKBACK_DAYS,
    NORMAL_MAX_NEW_MESSAGES,
    NORMAL_MAX_SCANNED_MESSAGES
  );
}

/**
 * 未処理通知が21件以上ある場合などの手動復旧用。
 * 直近7日・最大100件まで処理する。
 */
function anaPayToZaimManual() {
  runAnaPaySync_(
    "manual",
    INITIAL_LOOKBACK_DAYS,
    WIDE_MAX_NEW_MESSAGES,
    WIDE_MAX_SCANNED_MESSAGES
  );
}

/**
 * 初回に「過去7日分は取り込まず、これからの通知だけで始めたい」場合に1回だけ実行。
 * Zaimには何も登録せず、直近7日分を処理済みとして記録する。
 */
function markRecentAnaPayMessagesAsProcessed() {
  const lock = LockService.getScriptLock();

  if (!lock.tryLock(5000)) {
    throw new Error("別の処理が実行中です。少し待ってから再実行してください。");
  }

  try {
    const result = collectPendingAnaPayMessages_(
      INITIAL_LOOKBACK_DAYS,
      WIDE_MAX_NEW_MESSAGES,
      WIDE_MAX_SCANNED_MESSAGES
    );

    if (result.scanOverflow) {
      throw new Error(
        "ANA Pay通知の検索件数が上限に達したため処理を中止しました。" +
        "処理済み設定は変更していません。"
      );
    }

    if (result.limitOverflow) {
      throw new Error(
        "直近7日間の未処理ANA Pay通知が101件以上あります。" +
        "処理済み設定は変更していません。対象件数を確認してから再実行してください。"
      );
    }

    result.duplicateMailMarks.forEach(function(mark) {
      rememberDoneTokens_(mark.dateKey, [mark.token]);
    });

    result.pending.forEach(function(item) {
      if (item.txToken) {
        rememberDoneTokens_(item.transactionDateKey, ["T:" + item.txToken]);
      }
      rememberDoneTokens_(item.mailDateKey, ["M:" + item.mailToken]);
    });

    USER_PROPS.setProperty(INITIALIZED_KEY, "1");
    USER_PROPS.setProperty(LAST_SUCCESS_AT_KEY, String(Date.now()));
    cleanupOldDoneBuckets_();

    Logger.log(
      "直近" + INITIAL_LOOKBACK_DAYS + "日分のANA Pay通知 " +
      result.pending.length +
      "件を処理済みにしました。Zaimへの登録は行っていません。"
    );
  } finally {
    lock.releaseLock();
  }
}

function runAnaPaySync_(mode, lookbackDays, maxNewMessages, maxScannedMessages) {
  const lock = LockService.getScriptLock();

  if (!lock.tryLock(5000)) {
    throw new Error("別の処理が実行中です。少し待ってから再実行してください。");
  }

  try {
    const service = getService();

    if (!service.hasAccess()) {
      Logger.log(
        "【重要】次のURLを開いてZaimで認証してください:\n%s",
        service.authorize()
      );
      return;
    }

    const settings = getZaimSettings_();
    validateZaimSettings_(settings);

    const result = collectPendingAnaPayMessages_(
      lookbackDays,
      maxNewMessages,
      maxScannedMessages
    );

    if (result.scanOverflow) {
      throw new Error(
        "ANA Pay通知の検索件数が上限に達したため、今回はZaimへ1件も登録していません。" +
        (mode === "normal"
          ? "Google Apps Scriptを開き、関数 anaPayToZaimManual を1回実行してください。"
          : "対象件数を確認してから再実行してください。")
      );
    }

    if (result.limitOverflow) {
      throwLimitError_(mode, maxNewMessages);
    }

    result.duplicateMailMarks.forEach(function(mark) {
      rememberDoneTokens_(mark.dateKey, [mark.token]);
    });

    let registered = 0;
    let skipped = 0;

    result.pending.forEach(function(item) {
      const transaction = item.transaction;

      if (transaction.currency !== "JPY") {
        Logger.log(
          "日本円以外のため自動登録をスキップ: " +
          transaction.displayDateTime + " " +
          transaction.amount + " " + transaction.currency
        );

        if (item.txToken) {
          rememberDoneTokens_(item.transactionDateKey, ["T:" + item.txToken]);
        }
        rememberDoneTokens_(item.mailDateKey, ["M:" + item.mailToken]);
        skipped++;
        return;
      }

      if (!Number.isInteger(transaction.amount)) {
        throw new Error(
          "日本円金額が整数ではないため登録できません: " +
          transaction.rawAmount
        );
      }

      let postUrl;
      let payload;

      if (
        transaction.type === "charge" ||
        transaction.type === "auto_charge"
      ) {
        postUrl = "https://api.zaim.net/v2/home/money/income";
        payload = {
          mapping: 1,
          category_id: settings.incomeCategoryId,
          amount: transaction.amount,
          date: transaction.date,
          place: transaction.place,
          to_account_id: settings.anaPaymentId,
          comment:
            "🤖GAS自動登録 " +
            transaction.displayDateTime +
            "（振替待ち・メール受信日時）"
        };
      } else {
        postUrl = "https://api.zaim.net/v2/home/money/payment";
        payload = {
          mapping: 1,
          category_id: settings.paymentCategoryId,
          genre_id: settings.paymentGenreId,
          amount: transaction.amount,
          date: transaction.date,
          place: transaction.place,
          from_account_id: settings.anaPaymentId,
          comment: "🤖GAS自動登録 " + transaction.displayDateTime
        };
      }

      postForm_(service, postUrl, payload);

      if (item.txToken) {
        rememberDoneTokens_(item.transactionDateKey, ["T:" + item.txToken]);
      }
      rememberDoneTokens_(item.mailDateKey, ["M:" + item.mailToken]);

      registered++;

      Logger.log(
        "登録完了: " +
        transaction.displayDateTime + " " +
        transaction.place + " " +
        transaction.amount + "円"
      );
    });

    USER_PROPS.setProperty(INITIALIZED_KEY, "1");
    USER_PROPS.setProperty(LAST_SUCCESS_AT_KEY, String(Date.now()));
    cleanupOldDoneBuckets_();

    Logger.log(
      "処理完了: 登録 " + registered + "件 / スキップ " + skipped + "件"
    );
  } finally {
    lock.releaseLock();
  }
}

function throwLimitError_(mode, maxNewMessages) {
  if (mode === "normal") {
    throw new Error(
      "ANA Payの自動登録を保留しました。未処理のANA Pay通知が21件以上あり、" +
      "通常実行の上限20件を超えています。今回はZaimへ1件も登録していません。" +
      "Google Apps Scriptを開き、関数 anaPayToZaimManual を1回実行してください。" +
      "手動実行では最大100件まで処理できます。"
    );
  }

  if (mode === "initial") {
    throw new Error(
      "初回取り込み対象のANA Pay通知が" +
      (maxNewMessages + 1) +
      "件以上あります。今回はZaimへ1件も登録していません。" +
      "対象件数を確認してから再実行してください。"
    );
  }

  throw new Error(
    "手動取り込み対象のANA Pay通知が" +
    (maxNewMessages + 1) +
    "件以上あります。今回はZaimへ1件も登録していません。" +
    "対象件数を確認してから再実行してください。"
  );
}

function getZaimSettings_() {
  return {
    anaPaymentId: getNumberProperty_("ANA_PAYMENT_ID"),
    incomeCategoryId: getNumberProperty_("DEFAULT_INCOME_CATEGORY_ID"),
    paymentCategoryId: getNumberProperty_("DEFAULT_CATEGORY_ID"),
    paymentGenreId: getNumberProperty_("DEFAULT_GENRE_ID")
  };
}

function validateZaimSettings_(settings) {
  if (!settings.anaPaymentId) {
    throw new Error("ANA_PAYMENT_ID が未設定です。");
  }
  if (!settings.incomeCategoryId) {
    throw new Error("DEFAULT_INCOME_CATEGORY_ID が未設定です。");
  }
  if (!settings.paymentCategoryId || !settings.paymentGenreId) {
    throw new Error(
      "DEFAULT_CATEGORY_ID または DEFAULT_GENRE_ID が未設定です。"
    );
  }
}

function collectPendingAnaPayMessages_(
  lookbackDays,
  maxNewMessages,
  maxScannedMessages
) {
  const query =
    "from:" + ANA_PAY_SENDER +
    " newer_than:" + lookbackDays + "d";

  const cutoff =
    Date.now() - lookbackDays * 24 * 60 * 60 * 1000;

  const seenMessageIds = {};
  const seenTransactionTokens = {};
  const pending = [];
  const duplicateMailMarks = [];

  let start = 0;
  let scannedMessages = 0;

  while (true) {
    const threads = GmailApp.search(query, start, GMAIL_PAGE_SIZE);

    if (threads.length === 0) {
      break;
    }

    for (let i = 0; i < threads.length; i++) {
      const messages = threads[i].getMessages();

      for (let j = 0; j < messages.length; j++) {
        const message = messages[j];
        const messageId = message.getId();

        if (seenMessageIds[messageId]) {
          continue;
        }
        seenMessageIds[messageId] = true;

        if (message.getDate().getTime() < cutoff) {
          continue;
        }

        scannedMessages++;
        if (scannedMessages > maxScannedMessages) {
          return {
            pending: [],
            duplicateMailMarks: [],
            limitOverflow: false,
            scanOverflow: true
          };
        }

        const transaction = parseAnaPayMessage_(message);
        if (!transaction) {
          continue;
        }

        const mailToken = shortHash_("MAIL|" + messageId);
        const mailDateKey = formatDateKey_(message.getDate());

        if (hasDoneToken_(mailDateKey, "M:" + mailToken)) {
          continue;
        }

        let txToken = null;
        const transactionDateKey = transaction.date;

        if (transaction.type === "payment") {
          txToken = shortHash_(
            "TX|" + buildPaymentTransactionKey_(transaction)
          );

          if (
            hasDoneToken_(transactionDateKey, "T:" + txToken) ||
            seenTransactionTokens[txToken]
          ) {
            duplicateMailMarks.push({
              dateKey: mailDateKey,
              token: "M:" + mailToken
            });
            continue;
          }

          seenTransactionTokens[txToken] = true;
        }

        pending.push({
          transaction: transaction,
          txToken: txToken,
          mailToken: mailToken,
          transactionDateKey: transactionDateKey,
          mailDateKey: mailDateKey
        });

        if (pending.length > maxNewMessages) {
          return {
            pending: [],
            duplicateMailMarks: [],
            limitOverflow: true,
            scanOverflow: false
          };
        }
      }
    }

    start += threads.length;

    if (threads.length < GMAIL_PAGE_SIZE) {
      break;
    }
  }

  return {
    pending: pending,
    duplicateMailMarks: duplicateMailMarks,
    limitOverflow: false,
    scanOverflow: false
  };
}

function parseAnaPayMessage_(message) {
  const subject = normalizeSpaces_(message.getSubject());
  const body = message.getPlainBody();
  const from = extractEmailAddress_(message.getFrom());

  if (from !== ANA_PAY_SENDER) {
    return null;
  }

  const isAnaPay = subject.indexOf("ANA Pay") !== -1;
  if (!isAnaPay) {
    return null;
  }

  const isPayment =
    subject.indexOf("ご利用のお知らせ") !== -1;

  const isAutoCharge =
    subject.indexOf("オートチャージ完了のお知らせ") !== -1;

  const isCharge =
    !isAutoCharge &&
    subject.indexOf("チャージ完了のお知らせ") !== -1;

  if (!isPayment && !isAutoCharge && !isCharge) {
    return null;
  }

  if (isPayment) {
    const dateTime = parseAnaPaymentDateTime_(body);
    const amountInfo = parseAnaAmount_(body, "ご利用金額");
    const place = parseAnaLineValue_(body, "ご利用店舗");

    if (!dateTime) {
      Logger.log(
        "ANA Payの利用日時を解析できません: " + message.getSubject()
      );
      return null;
    }

    if (!amountInfo) {
      Logger.log(
        "ANA Payの利用金額・通貨を解析できません: " +
        message.getSubject()
      );
      return null;
    }

    if (!place) {
      Logger.log(
        "ANA Payの利用店舗を解析できません: " + message.getSubject()
      );
      return null;
    }

    return {
      source: "ANA_PAY",
      type: "payment",
      date: dateTime.date,
      isoDateTime: dateTime.isoDateTime,
      displayDateTime: dateTime.displayDateTime,
      amount: amountInfo.amount,
      currency: amountInfo.currency,
      rawAmount: amountInfo.raw,
      place: place
    };
  }

  const amountInfo = parseAnaAmount_(body, "チャージ金額");
  const receivedDateTime = formatDateTimeFromDate_(message.getDate());

  if (!amountInfo) {
    Logger.log(
      "ANA Payのチャージ金額・通貨を解析できません: " +
      message.getSubject()
    );
    return null;
  }

  return {
    source: "ANA_PAY",
    type: isAutoCharge ? "auto_charge" : "charge",
    date: receivedDateTime.date,
    isoDateTime: receivedDateTime.isoDateTime,
    displayDateTime: receivedDateTime.displayDateTime,
    amount: amountInfo.amount,
    currency: amountInfo.currency,
    rawAmount: amountInfo.raw,
    place: isAutoCharge
      ? "ANA Payオートチャージ"
      : "ANA Payチャージ"
  };
}

function parseAnaPaymentDateTime_(body) {
  const lineMatch = body.match(
    /ご利用日時[：:]\s*([^\r\n]+)/
  );

  if (!lineMatch) {
    return null;
  }

  const raw = lineMatch[1].trim();

  let match = raw.match(
    /(\d{4})[-\/](\d{1,2})[-\/](\d{1,2})\s+(\d{1,2}):(\d{1,2})(?::(\d{1,2}))?/
  );

  if (!match) {
    match = raw.match(
      /(\d{4})年\s*(\d{1,2})月\s*(\d{1,2})日\s*(\d{1,2})時\s*(\d{1,2})分(?:\s*(\d{1,2})秒)?/
    );
  }

  if (!match) {
    return null;
  }

  const year = String(match[1]);
  const month = pad2_(match[2]);
  const day = pad2_(match[3]);
  const hour = pad2_(match[4]);
  const minute = pad2_(match[5]);
  const second = match[6] ? pad2_(match[6]) : null;

  const date = year + "-" + month + "-" + day;
  const isoDateTime =
    date +
    "T" +
    hour +
    ":" +
    minute +
    (second ? ":" + second : "");

  const displayDateTime =
    year +
    "/" +
    month +
    "/" +
    day +
    " " +
    hour +
    ":" +
    minute +
    (second ? ":" + second : "");

  return {
    date: date,
    isoDateTime: isoDateTime,
    displayDateTime: displayDateTime
  };
}

function parseAnaAmount_(body, label) {
  const regexp = new RegExp(
    escapeRegExp_(label) + "[：:]\\s*([^\\r\\n]+)"
  );

  const match = body.match(regexp);
  if (!match) {
    return null;
  }

  const raw = normalizeSpaces_(match[1]);
  const amountMatch = raw.match(/([\d,]+(?:\.\d+)?)/);

  if (!amountMatch) {
    return null;
  }

  const amount = Number(
    amountMatch[1].replace(/,/g, "")
  );

  if (!Number.isFinite(amount) || amount <= 0) {
    return null;
  }

  let currency = null;

  if (/[円¥￥]/.test(raw)) {
    currency = "JPY";
  } else {
    const currencyMatch = raw.match(/\b([A-Z]{3})\b/i);
    if (currencyMatch) {
      currency = currencyMatch[1].toUpperCase();
    }
  }

  if (!currency) {
    return null;
  }

  return {
    amount: amount,
    currency: currency,
    raw: raw
  };
}

function parseAnaLineValue_(body, label) {
  const regexp = new RegExp(
    escapeRegExp_(label) + "[：:]\\s*([^\\r\\n]+)"
  );

  const match = body.match(regexp);
  if (!match) {
    return null;
  }

  const value = normalizeSpaces_(match[1]);
  return value || null;
}

function buildPaymentTransactionKey_(transaction) {
  return [
    transaction.source,
    transaction.type,
    transaction.isoDateTime,
    String(transaction.amount),
    transaction.currency,
    normalizeSpaces_(transaction.place).toUpperCase()
  ].join("|");
}

function postForm_(service, url, payload) {
  const encodedPayload = Object.keys(payload)
    .map(function(key) {
      return (
        encodeURIComponent(key) +
        "=" +
        encodeURIComponent(payload[key])
      );
    })
    .join("&");

  const response = service.fetch(url, {
    method: "post",
    payload: encodedPayload,
    muteHttpExceptions: true
  });

  const status = response.getResponseCode();

  if (status < 200 || status >= 300) {
    throw new Error(
      "Zaim API HTTP " +
      status +
      ": " +
      response.getContentText()
    );
  }

  return response;
}

function getNumberProperty_(name) {
  const value = SCRIPT_PROPS.getProperty(name);
  if (!value) {
    return 0;
  }

  const number = Number(value);
  return Number.isFinite(number) ? number : 0;
}

function doneBucketPropertyKey_(dateKey) {
  return DONE_BUCKET_PREFIX + dateKey.replace(/-/g, "");
}

function loadDoneBucket_(dateKey) {
  const propertyKey = doneBucketPropertyKey_(dateKey);

  if (DONE_BUCKET_CACHE[propertyKey]) {
    return DONE_BUCKET_CACHE[propertyKey];
  }

  const raw = USER_PROPS.getProperty(propertyKey);
  let list = [];

  if (raw) {
    try {
      const parsed = JSON.parse(raw);
      if (Array.isArray(parsed)) {
        list = parsed;
      }
    } catch (e) {
      list = [];
    }
  }

  const bucket = {
    propertyKey: propertyKey,
    list: list,
    set: new Set(list)
  };

  DONE_BUCKET_CACHE[propertyKey] = bucket;
  return bucket;
}

function hasDoneToken_(dateKey, token) {
  return loadDoneBucket_(dateKey).set.has(token);
}

function rememberDoneTokens_(dateKey, tokens) {
  const bucket = loadDoneBucket_(dateKey);
  let changed = false;

  tokens.forEach(function(token) {
    if (!bucket.set.has(token)) {
      bucket.set.add(token);
      bucket.list.push(token);
      changed = true;
    }
  });

  if (changed) {
    USER_PROPS.setProperty(
      bucket.propertyKey,
      JSON.stringify(bucket.list)
    );
  }
}

function cleanupOldDoneBuckets_() {
  const allProperties = USER_PROPS.getProperties();
  const cutoffDate = new Date();
  cutoffDate.setDate(
    cutoffDate.getDate() - DONE_TOKEN_RETENTION_DAYS
  );

  const cutoffKey = Utilities.formatDate(
    cutoffDate,
    Session.getScriptTimeZone(),
    "yyyyMMdd"
  );

  Object.keys(allProperties).forEach(function(key) {
    if (key.indexOf(DONE_BUCKET_PREFIX) !== 0) {
      return;
    }

    const datePart = key.substring(
      DONE_BUCKET_PREFIX.length
    );

    if (/^\d{8}$/.test(datePart) && datePart < cutoffKey) {
      USER_PROPS.deleteProperty(key);
      delete DONE_BUCKET_CACHE[key];
    }
  });
}

function formatDateKey_(date) {
  return Utilities.formatDate(
    date,
    Session.getScriptTimeZone(),
    "yyyy-MM-dd"
  );
}

function formatDateTimeFromDate_(date) {
  return {
    date: Utilities.formatDate(
      date,
      Session.getScriptTimeZone(),
      "yyyy-MM-dd"
    ),
    isoDateTime: Utilities.formatDate(
      date,
      Session.getScriptTimeZone(),
      "yyyy-MM-dd'T'HH:mm:ss"
    ),
    displayDateTime: Utilities.formatDate(
      date,
      Session.getScriptTimeZone(),
      "yyyy/MM/dd HH:mm:ss"
    )
  };
}

function shortHash_(text) {
  const bytes = Utilities.computeDigest(
    Utilities.DigestAlgorithm.SHA_256,
    text,
    Utilities.Charset.UTF_8
  );

  return bytes
    .map(function(byte) {
      const unsigned = byte < 0 ? byte + 256 : byte;
      return unsigned.toString(16).padStart(2, "0");
    })
    .join("")
    .slice(0, 16);
}

function extractEmailAddress_(from) {
  const match = String(from || "").match(/<([^>]+)>/);
  return (match ? match[1] : String(from || ""))
    .trim()
    .toLowerCase();
}

function normalizeSpaces_(text) {
  return String(text || "")
    .replace(/\u00a0/g, " ")
    .replace(/\s+/g, " ")
    .trim();
}

function escapeRegExp_(text) {
  return text.replace(
    /[.*+?^${}()|[\]\\]/g,
    "\\$&"
  );
}

function pad2_(value) {
  return String(value).padStart(2, "0");
}