[X(Twitter) bot] How to create an X Bot that automatically posts from a spreadsheet in GAS: (3) Posting text + images

const CONSUMER_API_KEY = "XXX";
const CONSUMER_API_SECRET = "XXX";
const ACCESS_TOKEN = "XXX";
const ACCESS_TOKEN_SECRET = "XXX";
  
// OAuth1認証
const getTwitterService = function() {
  return OAuth1.createService( "Twitter" )
  .setAccessTokenUrl( "https://api.twitter.com/oauth/access_token" )
  .setRequestTokenUrl( "https://api.twitter.com/oauth/request_token" )
  .setAuthorizationUrl( "https://api.twitter.com/oauth/authorize" )
  .setConsumerKey( CONSUMER_API_KEY )
  .setConsumerSecret( CONSUMER_API_SECRET )
  .setAccessToken( ACCESS_TOKEN, ACCESS_TOKEN_SECRET )
  .setCallbackFunction('authCallback'); // コールバック関数名 
}

// OAuthコールバック
function authCallback(request) {
  const service = getTwitterService();
  const authorized = service.handleCallback(request);
  if (authorized) {
    return HtmlService.createHtmlOutput('Success!');
  } else {
    return HtmlService.createHtmlOutput('Denied.');
  }
}


function tweetWithImage() {
  const twitter = getTwitterService()
  var tweetData = pickUpTweet("twitter_text"); // ツイートの内容と画像URLを取得

  if(twitter.hasAccess()) {

    const endpoint1 = "https://upload.twitter.com/1.1/media/upload.json"
    const endpoint2 = "https://api.twitter.com/2/tweets";

    if (tweetData.imageUrl) {
      var imgBlob = UrlFetchApp.fetch(tweetData.imageUrl).getBlob();
      var img_64  = Utilities.base64Encode(imgBlob.getBytes()); //Blobを経由してBase64に変換

      var img_option = { 'method':"POST", 'payload':{'media_data':img_64} };
      var image_repsponse = twitter.fetch(endpoint1,img_option); 
      var image_result = JSON.parse(image_repsponse.getContentText());
      
      var mediainfo = {
        media_ids: [image_result['media_id_string']]
      }
      var payload = {
        text: tweetData.text,
        media: mediainfo
      }

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

      var result = JSON.parse(response.getContentText());

    } else {
      Logger.log(service.getLastError())
    }
  }
}


function pickUpTweet(sheetName) {
  const sheet = SpreadsheetApp.getActiveSpreadsheet().getSheetByName(sheetName);
  const lastRow = sheet.getLastRow();
  const data = sheet.getRange("A1:F" + lastRow).getValues();

  const availableTweets = data.filter(function(value) {
    return value[1] == '';
  });

  if (availableTweets.length == 0) return { text: '', imageUrl: '' };

  const weights = availableTweets.map(function(value) {
    return value[4]; // Assuming the weight is in column E
  });

  const alias = new AliasMethod(weights);
  const selectedIndex = alias.next();

  const selectedRow = availableTweets[selectedIndex][0];
  Logger.log("Selected row: " + selectedRow); // Log the selected row number

  sheet.getRange(selectedRow + 1, 2).setValue(new Date());

  return {
    text: availableTweets[selectedIndex][2], // Assuming the text is in column C
    imageUrl: availableTweets[selectedIndex][5] // Assuming the image URL is in column F
  };
}

class AliasMethod {
  constructor(weights) {
    this.prob = [];
    this.alias = [];
    this.n = weights.length;

    const small = [];
    const large = [];
    const scaledWeights = weights.map((w) => w * this.n);

    for (let i = 0; i < this.n; i++) {
      if (scaledWeights[i] < 1) {
        small.push(i);
      } else {
        large.push(i);
      }
    }

    while (small.length > 0 && large.length > 0) {
      const l = small.pop();
      const g = large.pop();

      this.prob[l] = scaledWeights[l];
      this.alias[l] = g;

      scaledWeights[g] = scaledWeights[g] + scaledWeights[l] - 1;

      if (scaledWeights[g] < 1) {
        small.push(g);
      } else {
        large.push(g);
      }
    }

    while (large.length > 0) {
      const g = large.pop();
      this.prob[g] = 1;
    }

    while (small.length > 0) {
      const l = small.pop();
      this.prob[l] = 1;
    }
  }

  next() {
    const i = Math.floor(Math.random() * this.n);
    return Math.random() < this.prob[i] ? i : this.alias[i];
  }
}