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

/**
 * JAL Pay → Zaim 自動記帳
 *
 * 【通常運用】
 * ・6時間おきのトリガーを想定
 * ・直近1日分のJAL Pay通知を確認
 * ・未処理通知は1回最大20件まで
 *
 * 【初回・手動実行】
 * ・直近7日分を確認
 * ・最大100件まで処理
 *
 * 【記帳ルール】
 * ・JAL Pay決済：支出として登録
 * ・JAL 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");

// 初回・手動実行は直近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 = "JALPAY_INITIALIZED";
const LAST_SUCCESS_AT_KEY = "JALPAY_LAST_SUCCESS_AT";

// 処理済みトークンは日ごとに保存し、14日より古いものを削除
const DONE_BUCKET_PREFIX = "JALPAY_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("まず jalPayToZaim を実行して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 jalPayToZaim() {
  const initialized = USER_PROPS.getProperty(INITIALIZED_KEY) === "1";

  if (!initialized) {
    runJalPaySync_("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(
      "JAL Payの自動登録を保留しました。前回の正常終了から24時間以上経過しているため、" +
      "通常の1日検索では取りこぼす可能性があります。今回はZaimへ1件も登録していません。" +
      "Google Apps Scriptを開き、関数 jalPayToZaimManual を1回実行してください。"
    );
  }

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

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

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

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

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

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

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

    // 取引としては重複しているが、メールIDだけ未記録だったもの
    result.duplicateMailMarks.forEach(function(mark) {
      rememberDoneTokens_(mark.dateKey, [mark.token]);
    });

    result.pending.forEach(function(item) {
      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 + "日分のJAL Pay通知 " +
      result.pending.length + "件を処理済みにしました。Zaimへの登録は行っていません。"
    );
  } finally {
    lock.releaseLock();
  }
}

function runJalPaySync_(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);

    // Zaimへ書き込む前に、今回の未処理件数をすべて確認する
    const result = collectPendingJalPayMessages_(
      lookbackDays,
      maxNewMessages,
      maxScannedMessages
    );

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

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

    // 同一取引の別メールとして判定したメールIDだけを処理済みにする
    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;

      // 外貨を「40 GBP → 40円」のように誤登録しない
      if (transaction.currency !== "JPY") {
        Logger.log(
          "日本円以外のため自動登録をスキップ: " +
          transaction.displayDateTime + " " +
          transaction.amount + " " + transaction.currency
        );

        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") {
        postUrl = "https://api.zaim.net/v2/home/money/income";
        payload = {
          mapping: 1,
          category_id: settings.incomeCategoryId,
          amount: transaction.amount,
          date: transaction.date,
          place: "JAL Payチャージ",
          to_account_id: settings.jalPaymentId,
          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: "JAL Pay決済",
          from_account_id: settings.jalPaymentId,
          comment: "🤖GAS自動登録 " + transaction.displayDateTime
        };
      }

      // API登録に成功した取引だけ処理済みにする
      postForm_(service, postUrl, payload);
      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(
      "JAL Payの自動登録を保留しました。未処理のJAL Pay通知が21件以上あり、" +
      "通常実行の上限20件を超えています。今回はZaimへ1件も登録していません。" +
      "Google Apps Scriptを開き、関数 jalPayToZaimManual を1回実行してください。" +
      "手動実行では最大100件まで処理できます。"
    );
  }

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

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

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

function validateZaimSettings_(settings) {
  if (!settings.jalPaymentId) {
    throw new Error("JAL_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 が未設定です。");
  }
}

/**
 * Gmailをページングしながら、まだ処理していないJAL Pay取引を集める。
 * Zaimへの書き込みはここでは一切行わない。
 */
function collectPendingJalPayMessages_(lookbackDays, maxNewMessages, maxScannedMessages) {
  const query =
    "newer_than:" + lookbackDays +
    'd {subject:"【JAL Pay】" subject:"【JAL Pay/JAL Global WALLET】"}';

  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 = parseJalPayMessage_(message);
        if (!transaction) {
          continue;
        }

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

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

        const txToken = shortHash_("TX|" + buildTransactionKey_(transaction));
        const transactionDateKey = transaction.date;

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

        // 同じ実行内で同一取引の通知が複数見つかった場合も重複登録しない
        if (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
        });

        // 上限+1件を見つけた時点で、書き込み前に中止判断できる
        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
  };
}

// JAL Pay通知メールを共通形式の取引データへ変換
function parseJalPayMessage_(message) {
  const subject = message.getSubject();
  const body = message.getPlainBody();

  const isJalPay =
    subject.indexOf("【JAL Pay】") !== -1 ||
    subject.indexOf("【JAL Pay/JAL Global WALLET】") !== -1;

  if (!isJalPay) {
    return null;
  }

  const isCharge = subject.indexOf("チャージ完了") !== -1;
  const isPayment = subject.indexOf("ショッピングご利用") !== -1;

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

  const dateTime = parseJalDateTime_(body, isCharge);
  const amountInfo = parseJalAmount_(body, isCharge);

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

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

  return {
    source: "JAL_PAY",
    type: isCharge ? "charge" : "payment",
    date: dateTime.date,
    isoDateTime: dateTime.isoDateTime,
    displayDateTime: dateTime.displayDateTime,
    amount: amountInfo.amount,
    currency: amountInfo.currency,
    rawAmount: amountInfo.raw,
    place: isCharge ? "JAL Payチャージ" : "JAL Pay決済"
  };
}

// 「ご利用日時」「チャージ日時」を解析
function parseJalDateTime_(body, isCharge) {
  const label = isCharge ? "チャージ日時" : "ご利用日時";
  const lineRegexp = new RegExp(escapeRegExp_(label) + "[：:]\\s*([^\\r\\n]+)");
  const lineMatch = body.match(lineRegexp);

  if (!lineMatch) {
    return null;
  }

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

  let dateMatch = raw.match(/(\d{4})年\s*(\d{1,2})月\s*(\d{1,2})日/);

  // 表記変更への保険：2026-09-08 / 2026/09/08
  if (!dateMatch) {
    dateMatch = raw.match(/(\d{4})[-\/]([0-1]?\d)[-\/]([0-3]?\d)/);
  }

  if (!dateMatch) {
    return null;
  }

  let timeMatch = raw.match(/([0-2]?\d):([0-5]?\d)(?::([0-5]?\d))?/);

  // 14時32分 / 14時32分05秒 にも対応
  if (!timeMatch) {
    timeMatch = raw.match(/([0-2]?\d)時\s*([0-5]?\d)分(?:\s*([0-5]?\d)秒)?/);
  }

  // 時刻は重複判定と後日の照合に使うため、取得できない場合は自動登録しない
  if (!timeMatch) {
    return null;
  }

  const year = String(dateMatch[1]);
  const month = pad2_(dateMatch[2]);
  const day = pad2_(dateMatch[3]);
  const hour = pad2_(timeMatch[1]);
  const minute = pad2_(timeMatch[2]);
  const second = timeMatch[3] ? pad2_(timeMatch[3]) : 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 parseJalAmount_(body, isCharge) {
  const regexp = isCharge
    ? /チャージ金額(?:[（(]手数料差引後[）)])?[：:]\s*([^\r\n]+)/
    : /ご利用金額[：:]\s*([^\r\n]+)/;

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

  const raw = match[1].trim();
  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 buildTransactionKey_(transaction) {
  return [
    transaction.source,
    transaction.type,
    transaction.isoDateTime,
    String(transaction.amount),
    transaction.currency
  ].join("|");
}

// Zaim APIへPOST
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;
}

// 処理済み情報は日単位のPropertiesに保存する
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"
  );
}

// 生のメールIDや取引情報を保存しないため短いハッシュに変換
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 escapeRegExp_(text) {
  return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
}

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