@gameroom/cli/src/actions/priceCharting/reprice.js

A command line tool for Gameroom

const cosmetic = require('cosmetic'),
  { join, resolve } = require('path'),
  { calculateGamePrices, difference, dollarString, grGreen, timeout, tryRepeatedly, writeCSVFile } = require('../../helpers'),
  { Price_Charting } = require('../../models'),
  { spinner } = require('../../refs'),
  { models: { Price, Product } } = require('@gameroom/kit'),
  PRICE_CHARTING = cosmetic.cyan('price charting'),
  TRUE = 'true',
  FALSE = 'false'

module.exports = async ({ products, write }) => {
  if (!process.env.PRICE_CHARTING_TOKEN) throw new Error('missing price charting env keys')
  spinner.info(`repricing ${grGreen('gameroom')} from ${PRICE_CHARTING} @ ${new Date().toLocaleString()}`)

  const csv_data = []

  let matched = 0,
    unmatched = 0,
    prices_updated = 0

  for (const [i, product] of products.entries()) {
    // instantiate csv data
    const data = new Price_Charting.Update({
      // product
      product_name: product.name,
      product_subname: product.subname,
      product_id: product.id
    })

    spinner.text = `checking ${grGreen('product')} ${i}/${products.length}`

    // update csv data
    data.update({
      auto_priced: product.properties.auto_price,
      pcid: product.properties.pcid,
      baseline: product.properties.price_baseline
    })
    if (product.properties.auto_price === TRUE) {
      const prices = await tryRepeatedly(() => Price.get({ filter: { key: 'product_id', value: product.id } }), (err) => spinner.warn(`error getting ${grGreen('product')} ${product.id} ${grGreen('prices')}`))
      // prices
      const game_plus = prices.find(p => p.name === 'Disc Plus' || p.name === 'Cartridge Plus' || p.name === 'Boxed') 
      const game_only = prices.find(p => p.name === 'Disc Only' || p.name === 'Cartridge Only')
      const buy_in_game_plus = prices.find(p => p.name === 'Buy In Disc Plus' || p.name === 'Buy In Cartridge Plus' || p.name === 'Buy In Boxed or CIB')
      const buy_in_game_only = prices.find(p => p.name === 'Buy In Disc Only' || p.name === 'Buy In Cartridge Only')
      // warnings for missing prices
      if (!game_plus) spinner.warn(`${grGreen('product')} ${product.id} missing game_plus price`)
      if (!game_only) spinner.warn(`${grGreen('product')} ${product.id} missing game_only price`)
      if (!buy_in_game_plus) spinner.warn(`${grGreen('product')} ${product.id} missing buy_in_game_plus price`)
      if (!buy_in_game_only) spinner.warn(`${grGreen('product')} ${product.id} missing buy_in_game_only price`)

      let { game_plus_amount, game_only_amount, buy_in_game_plus_amount, buy_in_game_only_amount } = calculateGamePrices(product)
      // update prices
      let updated = false
      while (!updated) {
        try {
          // there is a price that is not locked, and there is an new amount that is different
          if (game_plus && !game_plus.locked && !isNaN(game_plus_amount) && difference(game_plus.amount, game_plus_amount)) {

            product.properties.last_game_plus_amount = game_plus.amount
            await Price.update({ id: game_plus.id, amount: game_plus_amount })
            spinner.succeed(`updated ${grGreen('price')} ${game_plus.id}`)

            data.update({ game_plus_update: TRUE, product_update: TRUE })
            prices_updated++
          }
          if (game_only && !game_only.locked && !isNaN(game_only_amount) && difference(game_only.amount, game_only_amount)) {

            product.properties.last_game_only_amount = game_only.amount
            await Price.update({ id: game_only.id, amount: game_only_amount })
            spinner.succeed(`updated ${grGreen('price')} ${game_only.id}`)

            data.update({ game_only_update: TRUE, product_update: TRUE })
            prices_updated++
          }
          if (buy_in_game_plus && !buy_in_game_plus.locked && !isNaN(buy_in_game_plus_amount) && difference(buy_in_game_plus.amount, buy_in_game_plus_amount)) {

            product.properties.last_buy_in_game_plus_amount = buy_in_game_plus.amount
            await Price.update({ id: buy_in_game_plus.id, amount: buy_in_game_plus_amount })
            spinner.succeed(`updated ${grGreen('price')} ${buy_in_game_plus.id}`)

            data.update({ buy_in_game_plus_update: TRUE, product_update: TRUE })
            prices_updated++
          }
          if (buy_in_game_only && !buy_in_game_only.locked && !isNaN(buy_in_game_only_amount) && difference(buy_in_game_only.amount, buy_in_game_only_amount)) {

            product.properties.last_buy_in_game_only_amount = buy_in_game_only.amount
            await Price.update({ id: buy_in_game_only.id, amount: buy_in_game_only_amount })
            spinner.succeed(`updated ${grGreen('price')} ${buy_in_game_only.id}`)

            data.update({ buy_in_game_only_update: TRUE, product_update: TRUE })
            prices_updated++
          }
          updated = true
        } catch(err) {
          spinner.warn(`error updating ${grGreen('prices')} for ${grGreen('product')} ${product.id} : ${err}`)
          await timeout()
        }
      }
      // amounts for csv
      const old_game_plus_amount = game_plus ? game_plus.amount : 0
      const old_game_only_amount = game_only ? game_only.amount : 0
      const old_buy_in_game_plus_amount = buy_in_game_plus ? Math.abs(buy_in_game_plus.amount) : 0
      const old_buy_in_game_only_amount = buy_in_game_only ? Math.abs(buy_in_game_only.amount) : 0
      buy_in_game_plus_amount = Math.abs(buy_in_game_plus_amount)
      buy_in_game_only_amount = Math.abs(buy_in_game_only_amount)
      // update csv
      data.update({
        // game_plus
        game_plus_id: game_plus ? game_plus.id : '',
        old_game_plus_amount: dollarString(old_game_plus_amount),
        new_game_plus_amount: dollarString(game_plus_amount),
        game_plus_difference: dollarString(game_plus_amount - old_game_plus_amount),
        // game_only
        game_only_id: game_only ? game_only.id : '',
        old_game_only_amount: dollarString(old_game_only_amount),
        new_game_only_amount: dollarString(game_only_amount),
        game_only_difference: dollarString(game_only_amount - old_game_only_amount),
        // buy_in_game_plus
        buy_in_game_plus_id: buy_in_game_plus ? buy_in_game_plus.id : '',
        old_buy_in_game_plus_amount: dollarString(old_buy_in_game_plus_amount),
        new_buy_in_game_plus_amount: dollarString(buy_in_game_plus_amount),
        buy_in_game_plus_difference: dollarString(buy_in_game_plus_amount - old_buy_in_game_plus_amount),
        // buy_in_game_only
        buy_in_game_only_id: buy_in_game_only ? buy_in_game_only.id : '',
        old_buy_in_game_only_amount: dollarString(old_buy_in_game_only_amount),
        new_buy_in_game_only_amount: dollarString(buy_in_game_only_amount),
        buy_in_game_only_difference: dollarString(buy_in_game_only_amount - old_buy_in_game_only_amount),
      })
      // end of auto pricing
    }
    csv_data.push(data)
  }
  if (write) {
    const path = await writeCSVFile(join(resolve(write === true ? '.' : write), 'gameroom_auto_pricer.csv'), csv_data)
    spinner.succeed(`wrote data to ${path}`)
  }
  spinner.info(`total: ${products.length}`)
  spinner.succeed(`prices updated: ${prices_updated}`)
  spinner.succeed(`completed ${PRICE_CHARTING} reprice @ ${new Date().toLocaleString()}`).stop()
}