Podcastが更新されたらSpotifyのプレイリストに追加してTwitter（X）に告知ポストをする方法

最新のPodcastエピソードがSpotifyで公開されたら、Spotifyのプレイリストに自動的に追加し、Twitter（X）に告知ツイートするシステムをGoogle Apps Script（GAS）を使って作成します。

この記事は以下の記事を参考にさせていただきました。
Youパパさん、感謝！

https://note.com/embed/notes/n195564d8e562

そして、記事だけだとわかりにくいので、動画にしました。
わかりにくければ、こちらをご覧ください。

https://youtu.be/IC9ln4mLsjM

手順 1: 必要なアカウントとAPIキーの準備

まずは、以下のアカウントを準備します。

Googleアカウント
Spotify Developerアカウント
Twitter (X) Developerアカウント

手順 2: Google Apps Scriptのセットアップ

Googleスプレッドシートを作成
- Googleドライブで新しいスプレッドシートを作成し、Podcastのプレイリストデータを管理します。
- テンプレートファイルはこちら
  - https://docs.google.com/spreadsheets/d/1H4bdFsXlGAS6s_E471GzH5DteDrrWiNerUVmnu_wQaI/edit?usp=sharing
Google Apps Scriptを開く
- スプレッドシートを開いた状態で、上部メニューの「拡張機能」→「Apps Script」をクリックします。
スクリプトエディタにコードを貼り付ける
- 新しいプロジェクトを作成し、次に示すコードを貼り付けます。

手順 3: ライブラリの追加

このシステムを作成するためには、Google Apps Scriptに外部ライブラリを追加する必要があります。以下のライブラリを追加してください。

1. TwitterWebService ライブラリの追加

スクリプトエディタの「ライブラリ」タブをクリックします。
「ライブラリを追加」をクリックし、以下のライブラリを検索して追加します。
- TwitterWebService
  - スクリプトID: 1rgo8rXsxi1DxI_5Xgo_t3irTw1Y5cxl2mGSkbozKsSXf2E_KBBPC3xTF
- OAuth1
  - スクリプトID: 1CXDCY5sqT9ph64fFwSzVtXnbjpSfWdRymafDrtIZ7Z_hwysTY7IIhi7s
- OAuth2
  - スクリプトID: 1B7FSrk5Zi6L1rSxxTDgDEUsPzlukDsi4KGuTMorsTQHhGBzBkMun4iDF

手順 4: Spotify APIとTwitter APIの設定

SpotifyとTwitterのAPIキーとシークレットを取得します。

Spotify APIの登録手順

Spotify Developerにアクセスし、アカウントを作成します。
新しいアプリを作成し、「クライアントID」と「クライアントシークレット」を取得します。
アプリの「Redirect URIs」に次のURLを追加します。

https://script.google.com/macros/s/{{デプロイID}}/usercallback

Twitter (X) APIの登録手順

Twitter Developerにアクセスし、アプリケーションを作成します。
「APIキー」と「APIシークレットキー」を取得します。
TwitterアプリのUser authentication settingsの「Callback URI / Redirect URL」には次のURLを追加します。

https://script.google.com/macros/d/{{スクリプトID}}/usercallback

手順 5. スクリプトプロパティの設定

スクリプトプロパティは、APIキーやIDを保管するためのものです。

スクリプトエディタの「ファイル」→「プロジェクトのプロパティ」→「スクリプトプロパティ」を開きます。
以下の項目を設定します。
- DEPLOY_ID：デプロイID
- NOTIFICATION_EMAIL：通知するメールアドレス
- SHEET_NAME：スプレッドシート内のシート名
- SPOTIFY_CLIENT_ID：Spotify APIページで表示されるCLIENT ID
- SPOTIFY_CLIENT_SECRET：Spotify APIページで表示されるCLIENT SECRET
- SPOTIFY_PODCAST_GUID：最新エピソードID「0」を入力
- SPOTIFY_PODCAST_ID：Spotifyの番組ID
- SPREADSHEET_ID：Google SheetのID
- TWITTER_ACCOUNT：Xのアカウント名
- TWITTER_API_KEY：X APIで取得したAPI_KEY
- TWITTER_API_SECRET_KEY：X APIで取得したAPI_SECRET_KEY
スクリプトで一発で指定する（※2024.09.27 追記）
- スクリプトプロパティーを関数で作成する方法がありました。以下のコードを貼り付けて、setLibraryProperties()を一度だけ実行してください。
  スクリプトプロパティーが設定されたのが確認できたら、関数ごと削除して大丈夫です。

function setScriptProperties() {
  const scriptProperties = PropertiesService.getScriptProperties();
  
  // スクリプトプロパティの設定
  const properties = {
    "SPREADSHEET_ID": "あなたのスプレッドシートID",
    "SHEET_NAME": "シート名",
    "DEPLOY_ID": "デプロイID",
    "NOTIFICATION_EMAIL": "あなたのメールアドレス",
    "SPOTIFY_CLIENT_ID": "あなたのSpotifyクライアントID",
    "SPOTIFY_CLIENT_SECRET": "あなたのSpotifyクライアントシークレット",
    "SPOTIFY_PODCAST_ID": "あなたのSpotifyポッドキャストID",
    "SPOTIFY_PLAYLIST_ID": "あなたのSpotifyプレイリストID",
    "TWITTER_ACCOUNT": "あなたのTwitterアカウント",
    "TWITTER_API_KEY": "あなたのTwitter APIキー",
    "TWITTER_API_SECRET_KEY": "あなたのTwitter APIシークレットキー"
  };

  // プロパティを一括で設定
  for (const [key, value] of Object.entries(properties)) {
    scriptProperties.setProperty(key, value);
  }

  Logger.log("スクリプトプロパティが設定されました。");
}

手順 6: Spotify APIとTwitter APIの認証

1. Spotify APIの認証

Spotifyの認証を行うためには、authorizeSpotify() 関数を実行します。

2. Twitter APIの認証

Twitterの認証を行うためには、authorizeTwitter() 関数を実行します。

おまけ: リセット機能の使い方

SpotifyまたはTwitterの認証やPodcast情報をリセットすることもできます。

1. Spotifyの認証をリセット

Spotifyの認証をリセットするには、resetSpotifyAuthorization() 関数を実行します。

2. Twitterの認証をリセット

Twitterの認証をリセットするには、resetTwitter() 関数を実行します。

3. SPOTIFY_PODCAST_GUID をリセットする

Spotifyで最新のPodcastエピソードを確認するために使用している SPOTIFY_PODCAST_GUID をリセットするには、resetSpotifyPodcastGuid() 関数を実行します。

手順 7: トリガーの設定

スクリプトを自動実行するためにトリガーを設定します。

スクリプトエディタの「時計」アイコンをクリックして、新しいトリガーを作成します。
checkPodcastRSS 関数を定期的に実行するための時間ベースのトリガーを設定します。

完成したコード

以下が最終的なコードです。これをGoogle Apps Scriptに貼り付けてください。

// ツイートのテンプレート
const tweetTemplate = "｜NEW｜番組タイトル\n\n" +
                      "≪{{PLAYLIST_TITLE}}≫\n" +
                      "{{EPISODE_TITLE}}\n\n" +
                      "聴く\n→{{EPISODE_URL}}\n\n" +
                      "プレイリスト\n→{{PLAYLIST_URL}}\n\n" +
                      "#ハッシュタグ";

// スクリプトプロパティの取得
const scriptProperties = PropertiesService.getScriptProperties();

const SPREADSHEET_ID = scriptProperties.getProperty("SPREADSHEET_ID");
const SHEET_NAME = scriptProperties.getProperty("SHEET_NAME");
const DEPLOY_ID = scriptProperties.getProperty("DEPLOY_ID");
const NOTIFICATION_EMAIL = scriptProperties.getProperty("NOTIFICATION_EMAIL");

const SPOTIFY_CLIENT_ID = scriptProperties.getProperty("SPOTIFY_CLIENT_ID");
const SPOTIFY_CLIENT_SECRET = scriptProperties.getProperty("SPOTIFY_CLIENT_SECRET");
const SPOTIFY_PODCAST_ID = scriptProperties.getProperty("SPOTIFY_PODCAST_ID");
const SPOTIFY_PODCAST_GUID = scriptProperties.getProperty("SPOTIFY_PODCAST_GUID");

const TWITTER_ACCOUNT = scriptProperties.getProperty("TWITTER_ACCOUNT");
const TWITTER_API_KEY = scriptProperties.getProperty("TWITTER_API_KEY");
const TWITTER_API_SECRET_KEY = scriptProperties.getProperty("TWITTER_API_SECRET_KEY");

const LASTEST_EPISODE_GUID = scriptProperties.getProperty("LASTEST_EPISODE_GUID");

// 認証用インスタンス
var twitterInstance = TwitterWebService.getInstance(TWITTER_API_KEY, TWITTER_API_SECRET_KEY);
twitterInstance.service_name = TWITTER_ACCOUNT;
twitterInstance.getService = function () {
  return OAuth1.createService(this.service_name)
    .setAccessTokenUrl("https://api.twitter.com/oauth/access_token")
    .setRequestTokenUrl("https://api.twitter.com/oauth/request_token")
    .setAuthorizationUrl("https://api.twitter.com/oauth/authorize")
    .setConsumerKey(this.consumer_key)
    .setConsumerSecret(this.consumer_secret)
    .setCallbackFunction("TwitterAuthCallback")
    .setPropertyStore(PropertiesService.getUserProperties());
};

// シート名でシートを取得する関数
function getSheetByName(spreadsheet, sheetName) {
  return spreadsheet.getSheetByName(sheetName); // シート名でシートを取得
}

// 公開日からプレイリストのタイトルを探す（本日の日付を基に）
function findPlaylistTitleByDate(currentDate) {
  var spreadsheet = SpreadsheetApp.openById(SPREADSHEET_ID);
  var sheet = getSheetByName(spreadsheet, SHEET_NAME); // シート名を使用
  if (!sheet) {
    Logger.log("指定されたシートが見つかりません。");
    return null;
  }
  
  var lastRow = sheet.getLastRow();
  var closestDate = null;
  var closestTitle = null;

  // 公開日（B列）を2行目から順に見ていき、一番近い日付を探す
  for (var i = 2; i <= lastRow; i++) {
    var publishDate = sheet.getRange(i, 2).getValue(); // B列が公開日
    
    // publishDateが日付オブジェクトでない場合、変換を試みる
    if (!(publishDate instanceof Date)) {
      publishDate = new Date(publishDate);
    }

    // 日付の比較を行う前に、両方の日付から時間部分を削除
    var currentDateWithoutTime = new Date(currentDate.getFullYear(), currentDate.getMonth(), currentDate.getDate());
    var publishDateWithoutTime = new Date(publishDate.getFullYear(), publishDate.getMonth(), publishDate.getDate());

    // 本日の日付と一致または通過した場合、その日付を記録
    if (publishDateWithoutTime <= currentDateWithoutTime) {
      closestDate = publishDate;
      closestTitle = sheet.getRange(i, 1).getValue(); // A列にプレイリストタイトル
    }
  }
  
  // 最も近い日付を返す
  if (closestDate && closestTitle) {
    Logger.log('公開日が一致または近い行を発見: ' + closestDate + ' タイトル: ' + closestTitle);
    return { playlistTitle: closestTitle, publishDate: closestDate };
  } else {
    Logger.log('公開日が一致する行が見つかりませんでした。');
    return null;
  }
}

// Spotify API 認証用
function getSpotifyService() {
  var redirectUri = "https://script.google.com/macros/s/" + DEPLOY_ID + "/usercallback";
  return OAuth2.createService("spotify")
    .setAuthorizationBaseUrl("https://accounts.spotify.com/authorize")
    .setTokenUrl("https://accounts.spotify.com/api/token")
    .setClientId(SPOTIFY_CLIENT_ID)
    .setClientSecret(SPOTIFY_CLIENT_SECRET)
    .setRedirectUri(redirectUri)
    .setPropertyStore(PropertiesService.getUserProperties())
    .setCallbackFunction("spotifyAuthCallback")
    .setScope("playlist-modify-public playlist-modify-private");
}

// Spotify認証のトリガー
function authorizeSpotify() {
  var service = getSpotifyService();
  if (service.hasAccess()) {
    Logger.log("既に認証されています。");
  } else {
    var authorizationUrl = service.getAuthorizationUrl();
    Logger.log("Spotifyの認証URL: " + authorizationUrl);
  }
}

// Spotify認証リセット（解除）
function resetSpotifyAuthorization() {
  var service = getSpotifyService();
  service.reset();
  Logger.log("Spotifyの認証がリセットされました。");
}

// Spotify認証後のコールバック処理
function spotifyAuthCallback(request) {
  var service = getSpotifyService();
  var authorized = service.handleCallback(request);
  if (authorized) {
    return HtmlService.createHtmlOutput("認証に成功しました。");
  } else {
    return HtmlService.createHtmlOutput("認証に失敗しました。");
  }
}

// SpotifyからPodcastエピソードを取得し、最新のものをプレイリストに追加
function checkPodcastRSS() {
  var service = getSpotifyService();
  if (!SPOTIFY_PODCAST_ID || !NOTIFICATION_EMAIL) {
    Logger.log("Podcast ID、または通知先メールアドレスが設定されていません。");
    return;
  }

  // エピソードの総数を取得するためのURL
  var totalEpisodesUrl = 'https://api.spotify.com/v1/shows/' + SPOTIFY_PODCAST_ID + '/episodes?market=JP';
  var options = {
    method: "GET",
    headers: {
      Authorization: "Bearer " + service.getAccessToken(),
      "Content-Type": "application/json",
    },
    muteHttpExceptions: true,
  };

  var totalEpisodesResponse = UrlFetchApp.fetch(totalEpisodesUrl, options);
  if (totalEpisodesResponse.getResponseCode() !== 200) {
    Logger.log("エピソード総数取得エラー: " + totalEpisodesResponse.getContentText());
    return;
  }

  var totalEpisodesJson = JSON.parse(totalEpisodesResponse.getContentText());
  var totalEpisodes = totalEpisodesJson.total; // エピソードの総数を取得

  // Spotifyエピソード取得順序を判定
  var order = getEpisodeOrder();
  var offset = (order === "ascending") ? totalEpisodes - 1 : 0; // 逆の順序に変更

  // 最新のエピソードを取得するためのURL（オフセットを使用）
  var latestEpisodeUrl = 'https://api.spotify.com/v1/shows/' + SPOTIFY_PODCAST_ID + '/episodes?market=JP&limit=1&offset=' + offset;

  var latestEpisodeResponse = UrlFetchApp.fetch(latestEpisodeUrl, options);
  if (latestEpisodeResponse.getResponseCode() !== 200) {
    Logger.log("エピソード取得エラー: " + latestEpisodeResponse.getContentText());
    return;
  }

  var latestEpisodeJson = JSON.parse(latestEpisodeResponse.getContentText());
  if (latestEpisodeJson && latestEpisodeJson.items && latestEpisodeJson.items.length > 0) {
    var latestEpisode = latestEpisodeJson.items[0];
    var latestEpisodeGuid = latestEpisode.id;

    // GUIDが以前のエピソードと同じ場合は処理を停止
    if (SPOTIFY_PODCAST_GUID === latestEpisodeGuid) {
      Logger.log('最新エピソードはすでに処理済みです。');
      return;
    }

    // プレイリスト名を取得
    var currentDate = new Date();
    var playlistData = findPlaylistTitleByDate(currentDate);
    if (!playlistData) {
      Logger.log("プレイリストデータが見つかりませんでした。");
      return;
    }

    var playlistTitle = playlistData.playlistTitle;
    var publishDate = playlistData.publishDate;

    // プレイリストにエピソードを追加
    var playlistInfo = findOrCreatePlaylist(service, playlistTitle);
    if (!playlistInfo) {
      Logger.log("プレイリストの作成に失敗しました。");
      return;
    }
    addPodcastToPlaylist(service, playlistInfo.id, latestEpisode.uri, latestEpisode.name, playlistTitle, publishDate);

    // エピソードが追加されたことを通知
    sendEmailNotification(NOTIFICATION_EMAIL, latestEpisode.name, playlistTitle, publishDate);

    // GUIDを更新
    scriptProperties.setProperty("SPOTIFY_PODCAST_GUID", latestEpisodeGuid);

    // ツイートの生成と投稿
    var tweetText = tweetTemplate
      .replace("{{PLAYLIST_TITLE}}", playlistTitle)
      .replace("{{EPISODE_TITLE}}", latestEpisode.name)
      .replace("{{EPISODE_URL}}", latestEpisode.external_urls.spotify)
      .replace("{{PLAYLIST_URL}}", playlistInfo.url);

    postTweet(tweetText, latestEpisode.images[0].url);
  } else {
    Logger.log("最新エピソードが見つかりませんでした。");
  }
}



// プレイリストが存在するか確認し、存在しなければ作成
function findOrCreatePlaylist(service, playlistTitle) {
  var options = {
    method: "GET",
    headers: {
      Authorization: "Bearer " + service.getAccessToken(),
      "Content-Type": "application/json",
    },
    muteHttpExceptions: true,
  };

  var url = "https://api.spotify.com/v1/me/playlists";
  var response = UrlFetchApp.fetch(url, options);
  var playlists = JSON.parse(response.getContentText()).items;

  Logger.log("取得したプレイリスト: " + JSON.stringify(playlists)); // 取得したプレイリストをログに出力

  for (var i = 0; i < playlists.length; i++) {
    Logger.log("チェック中のプレイリスト: " + playlists[i].name); // 各プレイリスト名をログに出力
    if (playlists[i].name === playlistTitle) {
      Logger.log("既存のプレイリストを発見: " + playlistTitle);
      return { id: playlists[i].id, url: playlists[i].external_urls.spotify }; // プレイリストIDとURLを返す
    }
  }

  var userResponse = UrlFetchApp.fetch("https://api.spotify.com/v1/me", options);
  var user = JSON.parse(userResponse.getContentText());
  var userId = user.id;

  Logger.log("プレイリストが存在しないため、新しく作成します: " + playlistTitle);
  var createOptions = {
    method: "POST",
    headers: {
      Authorization: 'Bearer ' + service.getAccessToken(),
      'Content-Type': 'application/json'
    },
    payload: JSON.stringify({
      name: playlistTitle,
      description: "自動作成プレイリスト",
      public: true, // ここをtrueに変更
    }),
  };

  var createResponse = UrlFetchApp.fetch("https://api.spotify.com/v1/users/" + userId + "/playlists", createOptions);
  Logger.log("プレイリスト作成レスポンス: " + createResponse.getContentText()); // レスポンスをログに出力
  var createdPlaylist = JSON.parse(createResponse.getContentText());

  // プレイリストのURLを取得
  if (createdPlaylist && createdPlaylist.id) {
    var playlistUrl = createdPlaylist.external_urls.spotify; // 作成したプレイリストのURLを取得
    Logger.log("作成したプレイリストのURL: " + playlistUrl);
    return { id: createdPlaylist.id, url: playlistUrl }; // プレイリストIDとURLを返す
  } else {
    Logger.log("プレイリストの作成に失敗しました。");
    return null;
  }
}

// プレイリストにエピソードを追加
function addPodcastToPlaylist(service, playlistId, episodeUri, episodeTitle, playlistTitle, publishDate) {
  var url = "https://api.spotify.com/v1/playlists/" + playlistId + "/tracks";
  var payload = {
    uris: [episodeUri],
  };
  var options = {
    method: "POST",
    headers: {
      Authorization: "Bearer " + service.getAccessToken(),
    },
    contentType: "application/json",
    payload: JSON.stringify(payload),
  };
  
  var response = UrlFetchApp.fetch(url, options);
  var responseJson = JSON.parse(response.getContentText());

  Logger.log("エピソードをプレイリストに追加しました。Response: " + JSON.stringify(responseJson));
  Logger.log("追加されたエピソード: " + episodeTitle + " プレイリスト: " + playlistTitle + " 公開日: " + publishDate);
}

// メール通知を送信する関数
function sendEmailNotification(emailAddress, episodeTitle, playlistTitle, publishDate) {
  var subject = "Spotifyプレイリストが更新されました";
  var message = "最新のエピソードがプレイリストに追加されました:\n" + "エピソードタイトル: " + episodeTitle + "\n" + "プレイリストタイトル: " + playlistTitle + "\n" + "公開日: " + publishDate;

  MailApp.sendEmail(emailAddress, subject, message);
  Logger.log("通知メールを送信しました: " + emailAddress);
}

// ツイートを投稿する関数
function postTweet(tweetText, imageUrl) {
  var service = twitterInstance.getService();

  if (service.hasAccess()) {
    var mediaId = null;
    if (imageUrl) {
      mediaId = uploadImage(service, imageUrl);
      if (!mediaId) {
        Logger.log("画像のアップロードに失敗しました。テキストのみでツイートします。");
      }
    }

    var url = "https://api.twitter.com/2/tweets";
    var payload = {
      text: tweetText,
    };

    if (mediaId) {
      payload.media = { media_ids: [mediaId] };
    }

    try {
      var response = service.fetch(url, {
        method: "post",
        contentType: "application/json",
        payload: JSON.stringify(payload),
        muteHttpExceptions: true,
      });

      var responseCode = response.getResponseCode();
      var responseText = response.getContentText();

      if (responseCode === 200 || responseCode === 201) {
        var result = JSON.parse(responseText);
        Logger.log("ツイートが投稿されました: %s", result.data.text);
      } else {
        Logger.log("ツイート投稿エラー: " + responseCode + " " + responseText);
      }
    } catch (e) {
      Logger.log("ツイート投稿中にエラーが発生しました: " + e.toString());
    }
  } else {
    Logger.log("%sの認証が必要です", TWITTER_ACCOUNT);
  }
}

// 画像をアップロードする関数

function uploadImage(service, imageUrl) {
  var response = UrlFetchApp.fetch(imageUrl);
  var contentType = response.getHeaders()['Content-Type'];
  var imageData = response.getBlob().setContentType(contentType);
  
  var uploadUrl = 'https://upload.twitter.com/1.1/media/upload.json';
  var boundary = Utilities.getUuid();

  var payload = '--' + boundary + '\r\n' +
                'Content-Disposition: form-data; name="media"; filename="image.jpg"\r\n' +
                'Content-Type: ' + contentType + '\r\n\r\n';

  var closeDelimiter = '\r\n--' + boundary + '--';

  var payloadBlob = Utilities.newBlob(payload).getBytes();
  var imageBlob = imageData.getBytes();
  var closeDelimiterBlob = Utilities.newBlob(closeDelimiter).getBytes();

  var multipartRequestBody = Utilities.newBlob(payloadBlob.concat(imageBlob).concat(closeDelimiterBlob));

  var uploadResponse = service.fetch(uploadUrl, {
    method: 'post',
    contentType: 'multipart/form-data; boundary=' + boundary,
    payload: multipartRequestBody,
    muteHttpExceptions: true
  });
  
  var responseCode = uploadResponse.getResponseCode();
  var responseText = uploadResponse.getContentText();
  
  if (responseCode !== 200) {
    Logger.log('画像アップロードエラー: ' + responseCode + ' ' + responseText);
    return null;
  }
  
  var uploadResult = JSON.parse(responseText);
  return uploadResult.media_id_string;
}



// Twitter認証
function authorizeTwitter() {
  var service = twitterInstance.getService();

  if (service.hasAccess()) {
    Logger.log("%sは認証済です", TWITTER_ACCOUNT);
  } else {
    var authorizationUrl = service.authorize();
    Logger.log("↓" + TWITTER_ACCOUNT + "の認証URL: " + authorizationUrl);
  }
}

// Twitter認証解除
function resetTwitter() {
  twitterInstance.reset();
  Logger.log("%sのアカウントの認証を解除しました", TWITTER_ACCOUNT);
}

// 認証後のコールバック
function TwitterAuthCallback(request) {
  return twitterInstance.authCallback(request);
}

// SPOTIFY_PODCAST_GUIDをリセットする関数
function resetSpotifyPodcastGuid() {
  const scriptProperties = PropertiesService.getScriptProperties();
  scriptProperties.setProperty("SPOTIFY_PODCAST_GUID", "0");
  Logger.log("SPOTIFY_PODCAST_GUIDがリセットされました。");
}


// Spotifyからエピソードを取得して昇順か降順か判定
function getEpisodeOrder() {
  var service = getSpotifyService();
  var url = 'https://api.spotify.com/v1/shows/' + SPOTIFY_PODCAST_ID + '/episodes?market=JP&limit=2';
  var options = {
    method: "GET",
    headers: {
      Authorization: "Bearer " + service.getAccessToken(),
      "Content-Type": "application/json",
    },
    muteHttpExceptions: true,
  };

  var response = UrlFetchApp.fetch(url, options);
  if (response.getResponseCode() !== 200) {
    Logger.log("エピソード取得エラー: " + response.getContentText());
    return;
  }

  var episodesJson = JSON.parse(response.getContentText());
  if (episodesJson.items && episodesJson.items.length >= 2) {
    var episode1 = episodesJson.items[0];
    var episode2 = episodesJson.items[1];

    var publishDate1 = new Date(episode1.release_date);
    var publishDate2 = new Date(episode2.release_date);

    if (publishDate1 < publishDate2) {
      Logger.log("エピソードは昇順で取得されています。");
      return "ascending";
    } else {
      Logger.log("エピソードは降順で取得されています。");
      return "descending";
    }
  } else {
    Logger.log("エピソードが十分に取得できませんでした。");
  }
}

// 取得順序に応じて適切にエピソードを取得
function fetchEpisodesBasedOnOrder() {
  var order = getEpisodeOrder();
  var offset = (order === "ascending") ? 0 : totalEpisodes - 1;

  var url = 'https://api.spotify.com/v1/shows/' + SPOTIFY_PODCAST_ID + '/episodes?market=JP&limit=1&offset=' + offset;
  var response = UrlFetchApp.fetch(url, options);
  
  if (response.getResponseCode() === 200) {
    // 処理続行
  } else {
    Logger.log("再取得エラー: " + response.getContentText());
  }
}

これで、Spotifyの最新エピソードが自動でTwitterにツイートされ、認証やデータのリセットが行えるシステムが完成しました。

コピペ用資料

Twitter API（Free）の申請文

Volunteer manages the website related to. Using the WordPress plugin with the Twitter API, you can use Twitter to send the latest information on the website to many people and plan not only to attract customers, but also to tweet tweets that many people like and retweet This is to analyze and transmit more useful information.

以上です。
一応、無料で全文公開しますが、もし役立ったという方がいれば、任意で投げ銭ください。

« 前の記事