【完全無料】SEO検索順位チェックツールを自作する方法 Search Console API × GASで順位自動取得＋毎日メール通知

{
  "timeZone": "Asia/Tokyo",
  "exceptionLogging": "STACKDRIVER",
  "runtimeVersion": "V8",
  "oauthScopes": [
    "https://www.googleapis.com/auth/spreadsheets",
    "https://www.googleapis.com/auth/script.external_request",
    "https://www.googleapis.com/auth/script.send_mail",
    "https://www.googleapis.com/auth/webmasters.readonly"
  ]
}

/*************************************************
 * 地方SEO分析ツール 最終版
 * 他サイト使い回し対応 / 日本語シート名対応
 * - Search Console API 直接取得
 * - 重複防止
 * - 検索クエリ分析
 * - ページ分析
 * - 改善キーワード抽出
 * - 地域分析
 * - 月次サマリー
 * - 変化チェック
 * - 要約メール送信
 * - 会社名 / 地域名 / 業種語句 / 採用語句を設定シートで変更可能
 *************************************************/

const シート設定 = "設定";
const シート検索データ = "検索データ";
const シート検索クエリ分析 = "検索クエリ分析";
const シートページ分析 = "ページ分析";
const シート改善キーワード = "改善キーワード";
const シート地域分析 = "地域分析";
const シート月次サマリー = "月次サマリー";
const シート変化チェック = "変化チェック";
const シートログ = "ログ";

/* =========================
 * 公開用実行関数
 * ========================= */

function 初期設定() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const 必要シート = [
    シート設定,
    シート検索データ,
    シート検索クエリ分析,
    シートページ分析,
    シート改善キーワード,
    シート地域分析,
    シート月次サマリー,
    シート変化チェック,
    シートログ
  ];

  必要シート.forEach(name => {
    if (!ss.getSheetByName(name)) ss.insertSheet(name);
  });

  ヘッダー初期化_();
  ログを書く_("INFO", "初期設定を完了しました");
}

function SEO分析を実行() {
  ヘッダー初期化_();
  検索データを取得_();
  検索クエリ分析を作成_();
  ページ分析を作成_();
  改善キーワードを作成_();
  地域分析を作成_();
  月次サマリーを作成_();
  変化チェックを作成_();
  要約レポートを送信_();
}

/* =========================
 * 1. Search Console から取得
 * ========================= */

function 検索データを取得_() {
  const 設定 = 設定を読む_();
  const siteUrl = String(設定["サイトURL"] || "").trim();
  const 取得日数 = Number(設定["取得日数"] || 28);
  const 遅延日数 = Number(設定["データ遅延日数"] || 2);

  if (!siteUrl) throw new Error("設定シートの『サイトURL』が未設定です");

  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const sheet = ss.getSheetByName(シート検索データ);

  const tz = "Asia/Tokyo";
  const now = new Date();
  const end = new Date(now.getTime() - 遅延日数 * 24 * 60 * 60 * 1000);
  const start = new Date(end.getTime() - (取得日数 - 1) * 24 * 60 * 60 * 1000);

  const 取得日時 = Utilities.formatDate(now, tz, "yyyy-MM-dd HH:mm:ss");
  const 集計開始日 = Utilities.formatDate(start, tz, "yyyy-MM-dd");
  const 集計終了日 = Utilities.formatDate(end, tz, "yyyy-MM-dd");

  const 辞書 = 辞書を読む_();

  const 既存キー集合 = 検索データキー集合を作る_(sheet);

  let startRow = 0;
  let hasMore = true;
  const 追加行 = [];

  while (hasMore) {
    const payload = {
      startDate: 集計開始日,
      endDate: 集計終了日,
      dimensions: ["query", "page"],
      rowLimit: 25000,
      startRow: startRow
    };

    const json = SearchConsoleAPIを呼ぶ_(siteUrl, payload);

    if (!json.rows || json.rows.length === 0) {
      hasMore = false;
      break;
    }

    json.rows.forEach(row => {
      const query = String((row.keys && row.keys[0]) || "").trim();
      const page = String((row.keys && row.keys[1]) || "").trim();

      const key = [集計開始日, 集計終了日, query, page].join("||");
      if (既存キー集合.has(key)) return;

      追加行.push([
        取得日時,
        集計開始日,
        集計終了日,
        query,
        page,
        Number(row.clicks || 0),
        Number(row.impressions || 0),
        Number(row.ctr || 0),
        Number(row.position || 0),
        検索タイプを分類_(query, 辞書),
        地域を分類_(query, 辞書),
        サービスを分類_(query, 辞書),
        指名検索か_(query, 辞書) ? "はい" : "",
        監視キーワード一致_(query, 辞書)
      ]);

      既存キー集合.add(key);
    });

    if (json.rows.length < 25000) {
      hasMore = false;
    } else {
      startRow += 25000;
      Utilities.sleep(300);
    }
  }

  if (追加行.length === 0) {
    ログを書く_("INFO", "新規追加データはありませんでした");
    return;
  }

  sheet.getRange(sheet.getLastRow() + 1, 1, 追加行.length, 追加行[0].length).setValues(追加行);
  ログを書く_("INFO", "検索データに " + 追加行.length + " 行追加しました");
}

function 検索データキー集合を作る_(sheet) {
  const set = new Set();
  const values = sheet.getDataRange().getValues();
  if (values.length < 2) return set;

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    const 開始日 = String(row[1] || "").trim();
    const 終了日 = String(row[2] || "").trim();
    const 検索キーワード = String(row[3] || "").trim();
    const ページURL = String(row[4] || "").trim();
    if (!開始日 || !終了日 || !検索キーワード) continue;
    set.add([開始日, 終了日, 検索キーワード, ページURL].join("||"));
  }
  return set;
}

/* =========================
 * 2. 最新期間の分析
 * ========================= */

function 検索クエリ分析を作成_() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const raw = ss.getSheetByName(シート検索データ);
  const out = ss.getSheetByName(シート検索クエリ分析);

  const values = raw.getDataRange().getValues();
  if (values.length < 2) return;

  const 最新期間 = 最新期間を取得_();
  if (!最新期間) return;

  const map = {};

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    const 開始日 = String(row[1] || "");
    const 終了日 = String(row[2] || "");
    if (開始日 !== 最新期間.開始日 || 終了日 !== 最新期間.終了日) continue;

    const 検索キーワード = String(row[3] || "").trim();
    const ページURL = String(row[4] || "").trim();
    const クリック数 = Number(row[5] || 0);
    const 表示回数 = Number(row[6] || 0);
    const CTR = Number(row[7] || 0);
    const 平均掲載順位 = Number(row[8] || 0);
    const 検索タイプ = String(row[9] || "");
    const 地域 = String(row[10] || "");
    const サービス分類 = String(row[11] || "");
    const 指名検索 = String(row[12] || "");

    if (!検索キーワード) continue;

    if (!map[検索キーワード]) {
      map[検索キーワード] = {
        検索キーワード,
        検索タイプ,
        地域,
        サービス分類,
        指名検索,
        クリック数合計: 0,
        表示回数合計: 0,
        ctr加重合計: 0,
        順位加重合計: 0,
        ページ集合: {}
      };
    }

    map[検索キーワード].クリック数合計 += クリック数;
    map[検索キーワード].表示回数合計 += 表示回数;
    map[検索キーワード].ctr加重合計 += CTR * 表示回数;
    map[検索キーワード].順位加重合計 += 平均掲載順位 * 表示回数;
    if (ページURL) map[検索キーワード].ページ集合[ページURL] = true;
  }

  out.clearContents();
  ヘッダー初期化_();

  const rows = [];
  Object.keys(map).sort().forEach(key => {
    const item = map[key];
    const imp = item.表示回数合計 || 0;
    const 平均CTR = imp ? item.ctr加重合計 / imp : 0;
    const 平均順位 = imp ? item.順位加重合計 / imp : 0;

    rows.push([
      item.検索キーワード,
      item.検索タイプ,
      item.地域,
      item.サービス分類,
      item.指名検索,
      item.クリック数合計,
      item.表示回数合計,
      平均CTR,
      平均順位,
      Object.keys(item.ページ集合).length,
      最新期間.開始日,
      最新期間.終了日
    ]);
  });

  if (rows.length > 0) {
    out.getRange(2, 1, rows.length, rows[0].length).setValues(rows);
  }

  ログを書く_("INFO", "検索クエリ分析を更新しました");
}

function ページ分析を作成_() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const raw = ss.getSheetByName(シート検索データ);
  const out = ss.getSheetByName(シートページ分析);

  const values = raw.getDataRange().getValues();
  if (values.length < 2) return;

  const 最新期間 = 最新期間を取得_();
  if (!最新期間) return;

  const map = {};

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    const 開始日 = String(row[1] || "");
    const 終了日 = String(row[2] || "");
    if (開始日 !== 最新期間.開始日 || 終了日 !== 最新期間.終了日) continue;

    const 検索キーワード = String(row[3] || "").trim();
    const ページURL = String(row[4] || "").trim();
    const クリック数 = Number(row[5] || 0);
    const 表示回数 = Number(row[6] || 0);
    const CTR = Number(row[7] || 0);
    const 平均掲載順位 = Number(row[8] || 0);

    if (!ページURL) continue;

    if (!map[ページURL]) {
      map[ページURL] = {
        ページURL,
        クリック数合計: 0,
        表示回数合計: 0,
        ctr加重合計: 0,
        順位加重合計: 0,
        検索キーワード集合: {}
      };
    }

    map[ページURL].クリック数合計 += クリック数;
    map[ページURL].表示回数合計 += 表示回数;
    map[ページURL].ctr加重合計 += CTR * 表示回数;
    map[ページURL].順位加重合計 += 平均掲載順位 * 表示回数;
    if (検索キーワード) map[ページURL].検索キーワード集合[検索キーワード] = true;
  }

  out.clearContents();
  ヘッダー初期化_();

  const rows = [];
  Object.keys(map).sort().forEach(key => {
    const item = map[key];
    const imp = item.表示回数合計 || 0;

    rows.push([
      item.ページURL,
      item.クリック数合計,
      item.表示回数合計,
      imp ? item.ctr加重合計 / imp : 0,
      imp ? item.順位加重合計 / imp : 0,
      Object.keys(item.検索キーワード集合).length,
      最新期間.開始日,
      最新期間.終了日
    ]);
  });

  if (rows.length > 0) {
    out.getRange(2, 1, rows.length, rows[0].length).setValues(rows);
  }

  ログを書く_("INFO", "ページ分析を更新しました");
}

function 改善キーワードを作成_() {
  const 設定 = 設定を読む_();
  const 最小表示回数 = Number(設定["改善候補最小表示回数"] || 20);
  const 順位下限 = Number(設定["改善候補順位下限"] || 5);
  const 順位上限 = Number(設定["改善候補順位上限"] || 20);

  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const src = ss.getSheetByName(シート検索クエリ分析);
  const out = ss.getSheetByName(シート改善キーワード);

  const values = src.getDataRange().getValues();
  if (values.length < 2) return;

  out.clearContents();
  ヘッダー初期化_();

  const rows = [];

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    const 検索キーワード = String(row[0] || "");
    const 検索タイプ = String(row[1] || "");
    const 地域 = String(row[2] || "");
    const サービス分類 = String(row[3] || "");
    const クリック数 = Number(row[5] || 0);
    const 表示回数 = Number(row[6] || 0);
    const CTR = Number(row[7] || 0);
    const 平均順位 = Number(row[8] || 0);

    if (表示回数 >= 最小表示回数 && 平均順位 >= 順位下限 && 平均順位 <= 順位上限) {
      let 改善タイプ = "順位改善";
      let 改善メモ = "本文補強・内部リンク・見出し最適化を検討";

      if (CTR < 0.03) {
        改善タイプ = "CTR改善";
        改善メモ = "title と description の改善余地あり";
      }

      rows.push([
        検索キーワード,
        検索タイプ,
        地域,
        サービス分類,
        クリック数,
        表示回数,
        CTR,
        平均順位,
        改善タイプ,
        改善メモ
      ]);
    }
  }

  if (rows.length > 0) {
    out.getRange(2, 1, rows.length, rows[0].length).setValues(rows);
  }

  ログを書く_("INFO", "改善キーワードを更新しました");
}

function 地域分析を作成_() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const src = ss.getSheetByName(シート検索クエリ分析);
  const out = ss.getSheetByName(シート地域分析);

  const values = src.getDataRange().getValues();
  if (values.length < 2) return;

  out.clearContents();
  out.appendRow([
    "地域",
    "クリック数合計",
    "表示回数合計",
    "平均CTR",
    "平均掲載順位",
    "検索キーワード数",
    "指名検索数",
    "地域×業種数",
    "採用検索数"
  ]);

  const map = {};

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    const 検索タイプ = String(row[1] || "");
    const 地域 = String(row[2] || "未分類");
    const 検索キーワード = String(row[0] || "");
    const クリック数 = Number(row[5] || 0);
    const 表示回数 = Number(row[6] || 0);
    const CTR = Number(row[7] || 0);
    const 平均順位 = Number(row[8] || 0);

    if (!map[地域]) {
      map[地域] = {
        クリック数合計: 0,
        表示回数合計: 0,
        ctr加重合計: 0,
        順位加重合計: 0,
        キーワード集合: {},
        指名検索数: 0,
        地域業種数: 0,
        採用検索数: 0
      };
    }

    map[地域].クリック数合計 += クリック数;
    map[地域].表示回数合計 += 表示回数;
    map[地域].ctr加重合計 += CTR * 表示回数;
    map[地域].順位加重合計 += 平均順位 * 表示回数;
    map[地域].キーワード集合[検索キーワード] = true;

    if (検索タイプ === "指名" || 検索タイプ === "指名×地域") map[地域].指名検索数++;
    if (検索タイプ === "地域×業種") map[地域].地域業種数++;
    if (検索タイプ === "採用") map[地域].採用検索数++;
  }

  const rows = [];
  Object.keys(map).sort().forEach(area => {
    const item = map[area];
    const imp = item.表示回数合計 || 0;
    rows.push([
      area,
      item.クリック数合計,
      item.表示回数合計,
      imp ? item.ctr加重合計 / imp : 0,
      imp ? item.順位加重合計 / imp : 0,
      Object.keys(item.キーワード集合).length,
      item.指名検索数,
      item.地域業種数,
      item.採用検索数
    ]);
  });

  if (rows.length > 0) {
    out.getRange(2, 1, rows.length, rows[0].length).setValues(rows);
  }

  ログを書く_("INFO", "地域分析を更新しました");
}

function 月次サマリーを作成_() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const src = ss.getSheetByName(シート検索クエリ分析);
  const out = ss.getSheetByName(シート月次サマリー);

  const values = src.getDataRange().getValues();
  if (values.length < 2) return;

  let 総クリック数 = 0;
  let 総表示回数 = 0;
  let ctr加重合計 = 0;
  let 順位加重合計 = 0;
  let 指名検索表示回数 = 0;
  let 地域検索表示回数 = 0;
  let 地域業種表示回数 = 0;
  let 採用検索表示回数 = 0;
  let 改善候補数 = 0;

  const 月 = Utilities.formatDate(new Date(), "Asia/Tokyo", "yyyy-MM");

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    const 検索タイプ = String(row[1] || "");
    const 表示回数 = Number(row[6] || 0);
    const CTR = Number(row[7] || 0);
    const 平均順位 = Number(row[8] || 0);

    総表示回数 += 表示回数;
    総クリック数 += Number(row[5] || 0);
    ctr加重合計 += CTR * 表示回数;
    順位加重合計 += 平均順位 * 表示回数;

    if (検索タイプ === "指名" || 検索タイプ === "指名×地域") 指名検索表示回数 += 表示回数;
    if (検索タイプ === "地域") 地域検索表示回数 += 表示回数;
    if (検索タイプ === "地域×業種") 地域業種表示回数 += 表示回数;
    if (検索タイプ === "採用") 採用検索表示回数 += 表示回数;
    if (表示回数 >= 20 && 平均順位 >= 5 && 平均順位 <= 20) 改善候補数++;
  }

  out.clearContents();
  out.appendRow([
    "月",
    "総クリック数",
    "総表示回数",
    "平均CTR",
    "平均掲載順位",
    "指名検索表示回数",
    "地域検索表示回数",
    "地域×業種表示回数",
    "採用検索表示回数",
    "改善候補数"
  ]);

  out.appendRow([
    月,
    総クリック数,
    総表示回数,
    総表示回数 ? ctr加重合計 / 総表示回数 : 0,
    総表示回数 ? 順位加重合計 / 総表示回数 : 0,
    指名検索表示回数,
    地域検索表示回数,
    地域業種表示回数,
    採用検索表示回数,
    改善候補数
  ]);

  ログを書く_("INFO", "月次サマリーを更新しました");
}

/* =========================
 * 3. 変化チェック
 * ========================= */

function 変化チェックを作成_() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const raw = ss.getSheetByName(シート検索データ);
  const out = ss.getSheetByName(シート変化チェック);

  const values = raw.getDataRange().getValues();
  if (values.length < 2) return;

  const periods = 期間一覧を取得_();
  if (periods.length < 2) {
    out.clearContents();
    out.appendRow([
      "検索キーワード",
      "前回表示回数",
      "今回表示回数",
      "前回平均掲載順位",
      "今回平均掲載順位",
      "表示回数差分",
      "順位差分",
      "判定"
    ]);
    return;
  }

  const prev = periods[periods.length - 2];
  const latest = periods[periods.length - 1];

  const prevMap = 期間別クエリ集計を作る_(values, prev.開始日, prev.終了日);
  const latestMap = 期間別クエリ集計を作る_(values, latest.開始日, latest.終了日);

  out.clearContents();
  out.appendRow([
    "検索キーワード",
    "前回表示回数",
    "今回表示回数",
    "前回平均掲載順位",
    "今回平均掲載順位",
    "表示回数差分",
    "順位差分",
    "判定"
  ]);

  const allKeys = new Set([...Object.keys(prevMap), ...Object.keys(latestMap)]);
  const rows = [];

  Array.from(allKeys).sort().forEach(query => {
    const p = prevMap[query] || { impressions: 0, position: "", exists: false };
    const l = latestMap[query] || { impressions: 0, position: "", exists: false };

    let 判定 = "";
    if (!p.exists && l.exists) {
      判定 = "新規出現";
    } else if (p.exists && !l.exists) {
      判定 = "消失";
    } else {
      const diffPos = Number(p.position || 0) - Number(l.position || 0);
      if (Math.abs(diffPos) >= 1) {
        判定 = diffPos > 0 ? "改善" : "悪化";
      } else {
        判定 = "横ばい";
      }
    }

    rows.push([
      query,
      p.impressions || 0,
      l.impressions || 0,
      p.position === "" ? "" : p.position,
      l.position === "" ? "" : l.position,
      (l.impressions || 0) - (p.impressions || 0),
      (p.position === "" || l.position === "") ? "" : Number(p.position || 0) - Number(l.position || 0),
      判定
    ]);
  });

  if (rows.length > 0) {
    out.getRange(2, 1, rows.length, rows[0].length).setValues(rows);
  }

  ログを書く_("INFO", "変化チェックを更新しました");
}

function 期間別クエリ集計を作る_(values, 開始日, 終了日) {
  const map = {};

  for (let i = 1; i < values.length; i++) {
    const row = values[i];
    if (String(row[1] || "") !== 開始日 || String(row[2] || "") !== 終了日) continue;

    const query = String(row[3] || "").trim();
    const impressions = Number(row[6] || 0);
    const position = Number(row[8] || 0);

    if (!query) continue;

    if (!map[query]) {
      map[query] = {
        impressions: 0,
        posWeighted: 0,
        exists: true
      };
    }

    map[query].impressions += impressions;
    map[query].posWeighted += position * impressions;
  }

  Object.keys(map).forEach(query => {
    const item = map[query];
    item.position = item.impressions ? item.posWeighted / item.impressions : "";
  });

  return map;
}

/* =========================
 * 4. メール
 * ========================= */

function 要約レポートを送信_() {
  const 設定 = 設定を読む_();
  const 通知メール = String(設定["通知メール"] || "").trim();
  if (!通知メール) return;

  const ss = SpreadsheetApp.getActiveSpreadsheet();
  const qSheet = ss.getSheetByName(シート検索クエリ分析);
  const oSheet = ss.getSheetByName(シート改善キーワード);
  const cSheet = ss.getSheetByName(シート変化チェック);

  const qValues = qSheet.getDataRange().getValues();
  const oValues = oSheet.getDataRange().getValues();
  const cValues = cSheet.getDataRange().getValues();

  let 指名表示回数 = 0;
  let 地域表示回数 = 0;
  let 採用表示回数 = 0;

  for (let i = 1; i < qValues.length; i++) {
    const row = qValues[i];
    const タイプ = String(row[1] || "");
    const imp = Number(row[6] || 0);

    if (タイプ === "指名" || タイプ === "指名×地域") 指名表示回数 += imp;
    if (タイプ === "地域" || タイプ === "地域×業種") 地域表示回数 += imp;
    if (タイプ === "採用") 採用表示回数 += imp;
  }

  const 改善行 = [];
  for (let i = 1; i < oValues.length; i++) {
    改善行.push(oValues[i]);
  }
  改善行.sort((a, b) => Number(b[5] || 0) - Number(a[5] || 0));

  const 新規出現 = [];
  const 改善 = [];
  const 悪化 = [];
  const 消失 = [];

  for (let i = 1; i < cValues.length; i++) {
    const row = cValues[i];
    const 判定 = String(row[7] || "");
    if (判定 === "新規出現") 新規出現.push(row);
    if (判定 === "改善") 改善.push(row);
    if (判定 === "悪化") 悪化.push(row);
    if (判定 === "消失") 消失.push(row);
  }

  let body = "";
  body += "地域SEO分析レポート\n\n";
  body += "【要約】\n";
  body += "指名検索表示回数: " + 指名表示回数 + "\n";
  body += "地域系検索表示回数: " + 地域表示回数 + "\n";
  body += "採用系検索表示回数: " + 採用表示回数 + "\n\n";

  body += "【改善キーワード 上位5件】\n";
  if (改善行.length === 0) {
    body += "なし\n";
  } else {
    改善行.slice(0, 5).forEach(r => {
      body += "- " + r[0] + " / 表示:" + r[5] + " / 順位:" + Number(r[7]).toFixed(1) + " / " + r[8] + "\n";
    });
  }

  body += "\n【新規出現キーワード 上位5件】\n";
  if (新規出現.length === 0) {
    body += "なし\n";
  } else {
    新規出現.slice(0, 5).forEach(r => {
      body += "- " + r[0] + " / 今回表示:" + r[2] + "\n";
    });
  }

  body += "\n【改善したキーワード 上位5件】\n";
  if (改善.length === 0) {
    body += "なし\n";
  } else {
    改善
      .sort((a, b) => Number(b[6] || 0) - Number(a[6] || 0))
      .slice(0, 5)
      .forEach(r => {
        body += "- " + r[0] + " / 前回:" + Number(r[3] || 0).toFixed(1) + " → 今回:" + Number(r[4] || 0).toFixed(1) + "\n";
      });
  }

  body += "\n【悪化したキーワード 上位5件】\n";
  if (悪化.length === 0) {
    body += "なし\n";
  } else {
    悪化
      .sort((a, b) => Number(a[6] || 0) - Number(b[6] || 0))
      .slice(0, 5)
      .forEach(r => {
        body += "- " + r[0] + " / 前回:" + Number(r[3] || 0).toFixed(1) + " → 今回:" + Number(r[4] || 0).toFixed(1) + "\n";
      });
  }

  body += "\n【消失キーワード 上位5件】\n";
  if (消失.length === 0) {
    body += "なし\n";
  } else {
    消失.slice(0, 5).forEach(r => {
      body += "- " + r[0] + " / 前回表示:" + r[1] + "\n";
    });
  }

  MailApp.sendEmail({
    to: 通知メール,
    subject: "地域SEO分析レポート",
    body: body
  });

  ログを書く_("INFO", "要約レポートを送信しました");
}

/* =========================
 * Search Console API
 * ========================= */

function SearchConsoleAPIを呼ぶ_(siteUrl, payload) {
  const url = "https://searchconsole.googleapis.com/webmasters/v3/sites/" +
    encodeURIComponent(siteUrl) + "/searchAnalytics/query";

  const res = UrlFetchApp.fetch(url, {
    method: "post",
    contentType: "application/json",
    headers: {
      Authorization: "Bearer " + ScriptApp.getOAuthToken()
    },
    payload: JSON.stringify(payload),
    muteHttpExceptions: true
  });

  const code = res.getResponseCode();
  const text = res.getContentText();

  if (code !== 200) {
    throw new Error("Search Console API エラー (" + code + "): " + text);
  }

  return JSON.parse(text);
}

/* =========================
 * ヘッダー
 * ========================= */

function ヘッダー初期化_() {
  const ss = SpreadsheetApp.getActiveSpreadsheet();

  const 検索データ = ss.getSheetByName(シート検索データ);
  if (検索データ.getLastRow() === 0) {
    検索データ.appendRow([
      "取得日時",
      "集計開始日",
      "集計終了日",
      "検索キーワード",
      "ページURL",
      "クリック数",
      "表示回数",
      "CTR",
      "平均掲載順位",
      "検索タイプ",
      "地域",
      "サービス分類",
      "指名検索",
      "監視キーワード一致"
    ]);
  }

  const 検索クエリ分析 = ss.getSheetByName(シート検索クエリ分析);
  if (検索クエリ分析.getLastRow() === 0) {
    検索クエリ分析.appendRow([
      "検索キーワード",
      "検索タイプ",
      "地域",
      "サービス分類",
      "指名検索",
      "クリック数合計",
      "表示回数合計",
      "平均CTR",
      "平均掲載順位",
      "表示されたページ数",
      "集計開始日",
      "集計終了日"
    ]);
  }

  const ページ分析 = ss.getSheetByName(シートページ分析);
  if (ページ分析.getLastRow() === 0) {
    ページ分析.appendRow([
      "ページURL",
      "クリック数合計",
      "表示回数合計",
      "平均CTR",
      "平均掲載順位",
      "検索キーワード数",
      "集計開始日",
      "集計終了日"
    ]);
  }

  const 改善キーワード = ss.getSheetByName(シート改善キーワード);
  if (改善キーワード.getLastRow() === 0) {
    改善キーワード.appendRow([
      "検索キーワード",
      "検索タイプ",
      "地域",
      "サービス分類",
      "クリック数",
      "表示回数",
      "CTR",
      "平均掲載順位",
      "改善タイプ",
      "改善メモ"
    ]);
  }

  const 地域分析 = ss.getSheetByName(シート地域分析);
  if (地域分析.getLastRow() === 0) {
    地域分析.appendRow([
      "地域",
      "クリック数合計",
      "表示回数合計",
      "平均CTR",
      "平均掲載順位",
      "検索キーワード数",
      "指名検索数",
      "地域×業種数",
      "採用検索数"
    ]);
  }

  const 月次サマリー = ss.getSheetByName(シート月次サマリー);
  if (月次サマリー.getLastRow() === 0) {
    月次サマリー.appendRow([
      "月",
      "総クリック数",
      "総表示回数",
      "平均CTR",
      "平均掲載順位",
      "指名検索表示回数",
      "地域検索表示回数",
      "地域×業種表示回数",
      "採用検索表示回数",
      "改善候補数"
    ]);
  }

  const 変化チェック = ss.getSheetByName(シート変化チェック);
  if (変化チェック.getLastRow() === 0) {
    変化チェック.appendRow([
      "検索キーワード",
      "前回表示回数",
      "今回表示回数",
      "前回平均掲載順位",
      "今回平均掲載順位",
      "表示回数差分",
      "順位差分",
      "判定"
    ]);
  }

  const ログ = ss.getSheetByName(シートログ);
  if (ログ.getLastRow() === 0) {
    ログ.appendRow([
      "記録日時",
      "レベル",
      "内容"
    ]);
  }
}

/* =========================
 * 期間系
 * ========================= */

function 最新期間を取得_() {
  const periods = 期間一覧を取得_();
  if (periods.length === 0) return null;
  return periods[periods.length - 1];
}

function 期間一覧を取得_() {
  const values = SpreadsheetApp.getActiveSpreadsheet()
    .getSheetByName(シート検索データ)
    .getDataRange()
    .getValues();

  const map = {};
  for (let i = 1; i < values.length; i++) {
    const start = String(values[i][1] || "").trim();
    const end = String(values[i][2] || "").trim();
    if (!start || !end) continue;
    map[start + "||" + end] = { 開始日: start, 終了日: end };
  }

  return Object.values(map).sort((a, b) => a.終了日.localeCompare(b.終了日));
}

/* =========================
 * 設定読み込み
 * ========================= */

function 設定を読む_() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(シート設定);
  const values = sheet.getRange(1, 1, Math.max(sheet.getLastRow(), 1), 2).getValues();

  const obj = {};
  values.forEach(row => {
    const key = String(row[0] || "").trim();
    const value = row[1];
    if (key) obj[key] = value;
  });
  return obj;
}

function 辞書を読む_() {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(シート設定);
  const lastRow = sheet.getLastRow();

  const 読み取り = function(col) {
    if (lastRow < 2) return [];
    return sheet
      .getRange(2, col, lastRow - 1, 1)
      .getValues()
      .flat()
      .map(v => String(v || "").trim())
      .filter(v => v !== "");
  };

  return {
    監視キーワード: 読み取り(4), // D列
    指名語句: 読み取り(5),       // E列
    地域語句: 読み取り(6),       // F列
    業種語句: 読み取り(7),       // G列
    採用語句: 読み取り(8)        // H列
  };
}

/* =========================
 * 分類ロジック
 * ========================= */

function 検索タイプを分類_(query, 辞書) {
  const q = 正規化_(query);
  辞書 = 辞書 || 辞書を読む_();

  const 指名あり = 辞書.指名語句.some(word => q.includes(正規化_(word)));
  const 地域あり = 辞書.地域語句.some(word => q.includes(正規化_(word)));
  const 業種あり = 辞書.業種語句.some(word => q.includes(正規化_(word)));
  const 採用あり = 辞書.採用語句.some(word => q.includes(正規化_(word)));

  if (指名あり && 地域あり) return "指名×地域";
  if (地域あり && 業種あり) return "地域×業種";
  if (指名あり) return "指名";
  if (採用あり) return "採用";
  if (地域あり) return "地域";
  if (業種あり) return "業種";
  return "その他";
}

function 地域を分類_(query, 辞書) {
  const q = 正規化_(query);
  辞書 = 辞書 || 辞書を読む_();

  for (let i = 0; i < 辞書.地域語句.length; i++) {
    const word = 辞書.地域語句[i];
    if (q.includes(正規化_(word))) return word;
  }
  return "未分類";
}

function サービスを分類_(query, 辞書) {
  const q = 正規化_(query);
  辞書 = 辞書 || 辞書を読む_();

  for (let i = 0; i < 辞書.業種語句.length; i++) {
    const word = 辞書.業種語句[i];
    if (q.includes(正規化_(word))) return word;
  }

  for (let i = 0; i < 辞書.採用語句.length; i++) {
    const word = 辞書.採用語句[i];
    if (q.includes(正規化_(word))) return "採用";
  }

  return "未分類";
}

function 指名検索か_(query, 辞書) {
  const q = 正規化_(query);
  辞書 = 辞書 || 辞書を読む_();
  return 辞書.指名語句.some(word => q.includes(正規化_(word)));
}

function 監視キーワード一致_(query, 辞書) {
  const q = 正規化_(query);
  辞書 = 辞書 || 辞書を読む_();

  for (let i = 0; i < 辞書.監視キーワード.length; i++) {
    const kw = 正規化_(辞書.監視キーワード[i]);
    if (kw && q.includes(kw)) return 辞書.監視キーワード[i];
  }
  return "";
}

/* =========================
 * 共通
 * ========================= */

function 正規化_(text) {
  return String(text || "")
    .trim()
    .replace(/\s+/g, " ")
    .toLowerCase();
}

function ログを書く_(level, message) {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(シートログ);
  const now = Utilities.formatDate(new Date(), "Asia/Tokyo", "yyyy-MM-dd HH:mm:ss");
  sheet.appendRow([now, level, message]);
}

香川県 ホームページ制作
香川県 WEB制作
東かがわ市 ホームページ制作

SEO順位レポート

香川県 WEB制作
昨日：9位
今日：6位
↑ +3

東かがわ市 ホームページ制作
昨日：3位
今日：5位
↓ -2