Advanced Features

const cookiePre = await logCookies(cookieJar);
if (cookiePre.includes('_checkout_queue_token')) {
  let token = cookiePre.split('_checkout_queue_token')[1].split(';')[0];
}

let typeName = 'PollContinue';
while (typeName === 'PollContinue') {
  const pollReq = await request.post({
    url: `${domain}/queue/poll`,
    headers: {
      'content-type': 'application/json'
    },
    body: JSON.stringify({
      "query": "\n      {\n        poll(token: $token) {\n          token\n          pollAfter\n        }\n      }\n    ",
      "variables": { "token": token }
    })
  });
  
  const pollRes = JSON.parse(pollReq.body);
  typeName = pollRes.data.poll.__typename;
  timeStamp = new Date(pollRes.data.poll.pollAfter).getTime();
  token = pollRes.data.poll.token;
}

const cookieAft = await logCookies(cookieJar);
const replayObject = JSON.parse(
  t(decodeURIComponent(
    cookieAft.split('_queue_replay_data=')[1].split(';')[0]
  ))
);

if (replayObject.method === 'GET') {
  urlReq = await request.get({
    url: replayObject.url,
    jar: cookieJar
  });
} else if (['PUT', 'PATCH', 'POST'].includes(replayObject.method)) {
  // Convert params to form-encoded body
  let body = [];
  let n = w(replayObject.params);
  // ... param processing ...
  urlReq = await request[replayObject.method.toLowerCase()]({
    url: replayObject.url,
    body: encodeURI(body.join('&'))
  });
}

const queueURL = checkoutURL;
let retryAfter = 0;
let status = 202;
let poll = 0;

while (parseInt(status) !== 200) {
  setRunningStatus(`Polling Queue ${poll}...`);
  await delay(retryAfter);
  
  let pollReq = await request.get({
    headers: {
      'User-Agent': getUA(),
      referer: checkoutURL
    },
    url: `${domain}/checkout/poll?js_poll=1`
  });
  
  status = pollReq.status;
  retryAfter = pollReq.headers['retry-after'] 
    ? parseInt(pollReq.headers['retry-after']) * 1000 
    : 5000;
  poll++;
}

if (thisthing.headers['retry-after']) {
  await delay(parseInt(thisthing.headers['retry-after']) * 1000);
}

if (thisthing.finalUrl.includes('throttle/queue')) {
  let ur = `${domain}/checkout`;
  if (queueURL.split('?')[1]) {
    ur += `?${queueURL.split('?')[1]}`;
  }
  thisthing = await request.get({
    url: ur,
    jar: cookieJar
  });
}

const checkout_url = decodeURIComponent(
  checkoutURL.split('checkout_url=')[1].split('&')[0]
);

const loginReq = await request.post({
  url: `${domain}/account/login`,
  headers: {
    'content-type': 'application/x-www-form-urlencoded',
    'user-agent': getUA()
  },
  body: `form_type=customer_login&utf8=✓&customer[email]=${
    item.shopifyEmail
  }&customer[password]=${item.shopifyPassword}&checkout_url=${encodeURI(
    checkout_url
  )}`
});

checkoutURL = loginReq.finalUrl;

if (checkoutURL.includes('/challenge')) {
  const challengeToken = await getCaptcha(
    checkoutURL,
    urlRes.split('sitekey: "')[1].split('"')[0]
  );
  
  challengeReq = await request.post({
    url: `${domain}/account/login`,
    body: encodeURI(
      `authenticity_token=${authToken}&g-recaptcha-response=${challengeToken}`
    )
  });
  
  checkoutURL = challengeReq.finalUrl;
}

const url = "https://" + item.website + "/products.json?limit=250&page=1&order=updated_at";
let stock = await request.get({ url });
let avaliableProduct = JSON.parse(stock.body).products;

const words = item.keywords.trim();
const keywordsArr = [...words.split(' ')];

if (!item.randomColor) {
  keywordsArr.push(item.color);
}

const forRemoval = [...avaliableProduct];
const removed = [];

for (let keyword in keywordsArr) {
  const activeWord = keywordsArr[keyword];
  
  for (let i in avaliableProduct) {
    const itemTest = avaliableProduct[i];
    
    // Exclusion: Remove if title contains word
    if (activeWord[0] === '-') {
      if (itemTest.title.toLowerCase()
          .includes(activeWord.toLowerCase().substring(1))) {
        removed.push(itemTest.id);
        forRemoval.splice(forRemoval.indexOf(itemTest), 1);
      }
    } 
    // Inclusion: Remove if title does NOT contain word
    else {
      const searchWord = activeWord[0] === '+' 
        ? activeWord.toLowerCase().substring(1)
        : activeWord.toLowerCase();
        
      if (!itemTest.title.toLowerCase().includes(searchWord)) {
        removed.push(itemTest.id);
        forRemoval.splice(forRemoval.indexOf(itemTest), 1);
      }
    }
  }
}

chosenProduct = forRemoval[0];