noblox.js-async 0.0.1-security → 4.6.9

package/lib/thumbnails/getLogo.js

@@ -0,0 +1,60 @@
+// Includes
+const http = require('../util/http.js').func
+
+// Args
+exports.required = ['group']
+exports.optional = ['size', 'circular', 'format']
+
+// Docs
+/**
+ * ✅ Get the group's logo.
+ * @category Group
+ * @alias getLogo
+ * @param {number} group - The id of the group.
+ * @param {GroupIconSize=} [size=150x150] - The size of the logo.
+ * @param {boolean=} [circular=false] - Get the circular version of the logo.
+ * @param {GroupIconFormat=} [format=Png] - The file format of the logo.
+ * @returns {Promise<string>}
+ * @example const noblox = require("noblox.js")
+ * const logo = await noblox.getLogo(1)
+**/
+
+// Define
+function getLogo (group, size, circular, format) {
+  const httpOpt = {
+    url: '//thumbnails.roblox.com/v1/groups/icons',
+    options: {
+      qs: {
+        groupIds: group,
+        size: size || '150x150',
+        format: format || 'Png',
+        isCircular: circular
+      },
+      json: true
+    }
+  }
+  return http(httpOpt)
+    .then(function (body) {
+      const error = body.errors && body.errors[0]
+
+      if (error) {
+        if (error.message === 'NotFound') {
+          throw new Error('An invalid UserID or GroupID was provided.')
+        } else {
+          throw new Error(error.message)
+        }
+      }
+
+      const thumbnailData = body.data[0]
+
+      if (thumbnailData.state !== 'Completed') {
+        throw new Error('The requested image has not been approved. Status: ' + thumbnailData.state)
+      }
+
+      return thumbnailData.imageUrl
+    })
+}
+
+exports.func = function (args) {
+  return getLogo(args.group)
+}

package/lib/thumbnails/getPlayerThumbnail.js

@@ -0,0 +1,121 @@
+// Includes
+const http = require('../util/http.js').func
+const { thumbnail: settings } = require('../../settings.json')
+
+// Args
+exports.required = ['userIds']
+exports.optional = ['size', 'format', 'isCircular', 'cropType', 'retryCount']
+
+// Variables
+const eligibleSizes = {
+  body: {
+    sizes: ['30x30', '48x48', '60x60', '75x75', '100x100', '110x110', '140x140', '150x150', '150x200', '180x180', '250x250', '352x352', '420x420', '720x720'],
+    endpoint: 'avatar'
+  },
+  bust: {
+    sizes: ['48x48', '50x50', '60x60', '75x75', '100x100', '150x150', '180x180', '352x352', '420x420'],
+    endpoint: 'avatar-bust'
+  },
+  headshot: {
+    sizes: ['48x48', '50x50', '60x60', '75x75', '100x100', '110x110', '150x150', '180x180', '352x352', '420x420', '720x720'],
+    endpoint: 'avatar-headshot'
+  }
+}
+
+// Docs
+/**
+ * ✅ Get a user's thumbnail.
+ * @category User
+ * @alias getPlayerThumbnail
+ * @param {number | Array<number>} userIds - The id or an array ids of thumbnails to be retrieved; 100
+ * @param {number | string=} [size=720x720] - The [size of the image to be returned]{@link https://noblox.js.org/thumbnailSizes.png}; defaults highest resolution
+ * @param {'png' | 'jpeg'=} [format=png] - The file format of the returned thumbnails
+ * @param {boolean=} [isCircular=false] - Return the circular version of the thumbnails
+ * @param {'Body' | 'Bust' | 'Headshot'=} [cropType=Body] - The style of thumbnail that will be returned
+ * @returns {Promise<PlayerThumbnailData[]>}
+ * @example const noblox = require("noblox.js")
+ * let thumbnail_default = await noblox.getPlayerThumbnail(2416399685)
+ * let thumbnail_circHeadshot = await noblox.getPlayerThumbnail(2416399685, 420, "png", true, "Headshot")
+ * let thumbnails_body = await noblox.getPlayerThumbnail([2416399685, 234567, 345678], "150x200", "jpeg", false, "Body")
+**/
+
+// Define
+function getPlayerThumbnail (userIds, size, format = 'png', isCircular = false, cropType = 'body', retryCount = settings.maxRetries) {
+  // Validate userIds
+  if (Array.isArray(userIds)) {
+    if (userIds.some(isNaN)) {
+      throw new Error('userIds must be a number or an array of numbers')
+    }
+    userIds = [...new Set(userIds)] // get rid of duplicates, endpoint response does this anyway
+    if (userIds.length > 100) {
+      throw new Error(`too many userIds provided (${userIds.length}); maximum 100`)
+    }
+  } else {
+    if (isNaN(userIds)) {
+      throw new Error('userId is not a number')
+    }
+    userIds = [userIds]
+  }
+
+  // Validate cropType
+  cropType = cropType.toLowerCase()
+  if (!Object.keys(eligibleSizes).includes(cropType)) {
+    throw new Error(`Invalid cropping type provided: ${cropType} | Use: ${Object.keys(eligibleSizes).join(', ')}`)
+  }
+  const { sizes, endpoint } = eligibleSizes[cropType]
+
+  // Validate size
+  size = size || sizes[sizes.length - 1]
+  if (typeof size === 'number') {
+    size = `${size}x${size}`
+  }
+  if (!sizes.includes(size)) {
+    throw new Error(`Invalid size parameter provided: ${size} | [${cropType.toUpperCase()}] Use: ${sizes.join(', ')}`)
+  }
+
+  // Validate format
+  if (format.toLowerCase() !== 'png' && format.toLowerCase() !== 'jpeg') {
+    throw new Error(`Invalid image type provided: ${format} | Use: png, jpeg`)
+  }
+
+  return http({
+    url: `https://thumbnails.roblox.com/v1/users/${endpoint}?userIds=${userIds.join(',')}&size=${size}&format=${format}&isCircular=${!!isCircular}`,
+    options: {
+      resolveWithFullResponse: true,
+      followRedirect: true
+    }
+  })
+    .then(async ({ statusCode, body }) => {
+      let { data, errors } = JSON.parse(body)
+      if (statusCode === 200) {
+        if (retryCount > 0) {
+          const pendingThumbnails = data.filter(obj => { return obj.state === 'Pending' }).map(obj => obj.targetId) // Get 'Pending' thumbnails as array of userIds
+          if (pendingThumbnails.length > 0) {
+            await timeout(settings.retryDelay) // small delay helps cache populate on Roblox's end; default 500ms
+            const updatedPending = await getPlayerThumbnail(pendingThumbnails, size, format, isCircular, cropType, --retryCount) // Recursively retry for # of maxRetries attempts; default 2
+            data = data.map(obj => updatedPending.find(o => o.targetId === obj.targetId) || obj) // Update primary array's values
+          }
+        }
+        data = data.map(obj => {
+          if (obj.state !== 'Completed') {
+            const settingsUrl = settings.failedUrl[obj.state.toLowerCase()] // user defined settings.json default image URL for blocked or pending thumbnails; default ""
+            obj.imageUrl = settingsUrl || `https://noblox.js.org/moderatedThumbnails/moderatedThumbnail_${size}.png`
+          }
+          return obj
+        })
+        return data
+      } else if (statusCode === 400) {
+        throw new Error(`Error Code ${errors.code}: ${errors.message} | endpoint: ${endpoint}, userIds: ${userIds.join(',')}, size: ${size}, isCircular: ${!!isCircular}`)
+      } else {
+        throw new Error(`An unknown error occurred with getPlayerThumbnail() | endpoint: ${endpoint}, userIds: ${userIds.join(',')}, size: ${size}, isCircular: ${!!isCircular}`)
+      }
+    })
+}
+
+function timeout (ms) {
+  return new Promise(resolve => { setTimeout(resolve, ms) })
+}
+
+exports.func = function ({ userIds, size, format, isCircular, cropType, retryCount }) {
+  return getPlayerThumbnail(userIds, size, format, isCircular, cropType, retryCount)
+}

package/lib/thumbnails/getThumbnails.js

@@ -0,0 +1,93 @@
+// Includes
+const http = require('../util/http.js').func
+const { thumbnail: settings } = require('../../settings.json')
+
+// Args
+exports.required = ['thumbnailRequests']
+exports.optional = []
+
+// Docs
+/**
+ * ✅ Get thumbnails for assets/players.
+ * @category Assets
+ * @alias getThumbnails
+ * @param {Array<ThumbnailRequest>} thumbnailRequests - The id or an array ids of thumbnails to be retrieved; 100
+ * @returns {Promise<ThumbnailData[]>}
+ * @example const noblox = require("noblox.js")
+ * const playerThumbnails = noblox.getThumbnails([
+ *  {
+ *    type: "AvatarHeadShot",
+ *    token: "270FF19ECB1AFCF25383A6F37C6AD307",
+ *    format: "png",
+ *    size: "150x150"
+ *   }, {
+ *    type: "AvatarBust",
+ *    targetId: 55549140,
+ *    isCircular: true,
+ *    format: "png",
+ *    size: "150x150"
+ *   }
+ * ])
+**/
+
+// Define
+function getThumbnails (requests, retryCount = settings.maxRetries) {
+  if (!Array.isArray(requests)) {
+    throw new Error('thumbnailRequests are not an array')
+  }
+
+  requests = [...new Set(requests)]
+  if (requests.length > 100) {
+    throw new Error(`Too many thumbnailRequests provided (${requests.length}); maximum 100`)
+  }
+
+  for (const request of requests) {
+    if (!request.size || !request.type) {
+      throw new Error('thumbnailRequest must have a size and type')
+    } else if (request.format && (request.format.toLowerCase() !== 'png' && request.format.toLowerCase() !== 'jpeg')) {
+      throw new Error(`Invalid image type provided: ${request.format} | Use: png, jpeg`)
+    }
+  }
+
+  return http({
+    url: 'https://thumbnails.roblox.com/v1/batch',
+    options: {
+      method: 'POST',
+      json: requests,
+      resolveWithFullResponse: true,
+      followRedirect: true
+    }
+  })
+    .then(async ({ statusCode, body }) => {
+      let { data, errors } = body
+      if (statusCode === 200) {
+        if (retryCount > 0) {
+          const pendingThumbnails = data.filter(obj => { return obj.state === 'Pending' }).map(obj => obj.targetId) // Get 'Pending' thumbnails as array of userIds
+          if (pendingThumbnails.length > 0) {
+            await timeout(settings.retryDelay) // small delay helps cache populate on Roblox's end; default 500ms
+            const updatedPending = await getThumbnails(pendingThumbnails, --retryCount) // Recursively retry for # of maxRetries attempts; default 2
+            data = data.map(obj => updatedPending.find(o => o.targetId === obj.targetId) || obj) // Update primary array's values
+          }
+        }
+        data = data.map(obj => {
+          if (obj.state !== 'Completed') {
+            obj.imageUrl = settings.failedUrl[obj.state.toLowerCase()] || obj.imageUrl
+          }
+          return obj
+        })
+        return data
+      } else if (statusCode === 400) {
+        throw new Error(`Error Code ${errors.code}: ${errors.message} | requests: ${JSON.stringify(requests)}`)
+      } else {
+        throw new Error(`An unknown error occurred with getThumbnails() | requests: ${JSON.stringify(requests)}`)
+      }
+    })
+}
+
+function timeout (ms) {
+  return new Promise(resolve => { setTimeout(resolve, ms) })
+}
+
+exports.func = function ({ thumbnailRequests }) {
+  return getThumbnails(thumbnailRequests)
+}

package/lib/trades/acceptTrade.js

@@ -0,0 +1,58 @@
+// Includes
+const http = require('../util/http.js').func
+const getGeneralToken = require('../util/getGeneralToken.js').func
+
+// Args
+exports.required = ['tradeId']
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 Accept an active trade.
+ * @category Trade
+ * @alias acceptTrade
+ * @param {number} tradeId - The tradeId to accept.
+ * @returns {Promise<void>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * noblox.acceptTrade(1234)
+**/
+
+// Define
+function acceptTrade (tradeId, jar, xcsrf) {
+  return new Promise((resolve, reject) => {
+    http({
+      url: '//trades.roblox.com/v1/trades/' + tradeId + '/accept',
+      options: {
+        method: 'POST',
+        resolveWithFullResponse: true,
+        jar: jar,
+        headers: {
+          'X-CSRF-TOKEN': xcsrf,
+          'Content-Type': 'application/json'
+        }
+      }
+    }).then((res) => {
+      if (res.statusCode === 200) {
+        resolve()
+      } else {
+        const body = JSON.parse(res.body) || {}
+
+        if (body.errors && body.errors.length > 0) {
+          const errors = body.errors.map((e) => {
+            return e.message
+          })
+          reject(new Error(`${res.statusCode} ${errors.join(', ')}`))
+        }
+      }
+    }).catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  const jar = args.jar
+  return getGeneralToken({ jar: jar })
+    .then(function (xcsrf) {
+      return acceptTrade(args.tradeId, jar, xcsrf)
+    })
+}

package/lib/trades/canTradeWith.js

@@ -0,0 +1,48 @@
+// Includes
+const http = require('../util/http.js').func
+
+// Args
+exports.required = ['userId']
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 Check if the signed in user can trade with another user.
+ * @category Trade
+ * @alias canTradeWith
+ * @param {number} userId - The id of the user.
+ * @returns {Promise<CanTradeResponse>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const canTrade = await noblox.canTradeWith(1234)
+**/
+
+// Define
+function canTradeWith (jar, userId) {
+  return new Promise((resolve, reject) => {
+    http({
+      url: '//trades.roblox.com/v1/users/' + userId + '/can-trade-with',
+      options: {
+        method: 'GET',
+        resolveWithFullResponse: true,
+        jar: jar
+      }
+    }).then((res) => {
+      if (res.statusCode === 200) {
+        resolve(JSON.parse(res.body))
+      } else {
+        const body = JSON.parse(res.body) || {}
+        if (body.errors && body.errors.length > 0) {
+          const errors = body.errors.map((e) => {
+            return e.message
+          })
+          reject(new Error(`${res.statusCode} ${errors.join(', ')}`))
+        }
+      }
+    }).catch(error => reject(error))
+  })
+}
+
+exports.func = (args) => {
+  return canTradeWith(args.jar, args.userId)
+}

package/lib/trades/counterTrade.js

@@ -0,0 +1,84 @@
+// Includes
+const http = require('../util/http.js').func
+const getGeneralToken = require('../util/getGeneralToken.js').func
+const getCurrentUser = require('../util/getCurrentUser.js').func
+
+// Args
+exports.required = ['tradeId', 'targetUserId', 'sendingOffer', 'receivingOffer']
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 Counter an active incoming trade.
+ * @category Trade
+ * @alias counterTrade
+ * @param {number} tradeId - The id of the active trade
+ * @param {number} targetUserId - The user to send the trade to.
+ * @param {TradeOffer} sendingOffer - The offer to send to the other user.
+ * @param {TradeOffer} recievingOffer - The offer you are requesting from the other user.
+ * @returns {Promise<SendTradeResponse>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * noblox.counterTrade(1234, 80231025, { userAssetIds: [23289506393] }, { userAssetIds: [32924150919] })
+**/
+
+// Define
+function counterTrade (tradeId, targetUserId, sendingOffer, receivingOffer, jar, xcsrf, loggedInUser) {
+  return new Promise((resolve, reject) => {
+    if (!sendingOffer.userAssetIds || !receivingOffer.userAssetIds) {
+      reject(new Error('Both offers must includes userAssetIds.'))
+    }
+
+    if (!sendingOffer.robux) sendingOffer.robux = 0
+    if (!receivingOffer.robux) receivingOffer.robux = 0
+
+    http({
+      url: '//trades.roblox.com/v1/trades/' + tradeId + '/counter',
+      options: {
+        method: 'POST',
+        resolveWithFullResponse: true,
+        jar: jar,
+        headers: {
+          'X-CSRF-TOKEN': xcsrf,
+          'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+          offers: [
+            {
+              userId: targetUserId,
+              ...receivingOffer
+            },
+            {
+              userId: loggedInUser,
+              ...sendingOffer
+            }
+          ]
+        })
+      }
+    }).then((res) => {
+      if (res.statusCode === 200) {
+        resolve(JSON.parse(res.body))
+      } else {
+        const body = JSON.parse(res.body) || {}
+
+        if (body.errors && body.errors.length > 0) {
+          const errors = body.errors.map((e) => {
+            return e.message
+          })
+          reject(new Error(`${res.statusCode} ${errors.join(', ')}`))
+        }
+      }
+    }).catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  const jar = args.jar
+  return Promise.all([
+    getGeneralToken({ jar: jar }),
+    getCurrentUser({ jar: jar, option: 'UserID' })
+  ])
+    .then(function (resolvedPromises) {
+      return counterTrade(args.tradeId, args.targetUserId, args.sendingOffer, args.receivingOffer, jar, resolvedPromises[0], resolvedPromises[1])
+    })
+}

package/lib/trades/declineTrade.js

@@ -0,0 +1,58 @@
+// Includes
+const http = require('../util/http.js').func
+const getGeneralToken = require('../util/getGeneralToken.js').func
+
+// Args
+exports.required = ['tradeId']
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 Decline an active trade.
+ * @category Trade
+ * @alias declineTrade
+ * @param {number} tradeId - The tradeId to decline.
+ * @returns {Promise<void>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * noblox.declineTrade(1234)
+**/
+
+// Define
+function declineTrade (tradeId, jar, xcsrf) {
+  return new Promise((resolve, reject) => {
+    http({
+      url: '//trades.roblox.com/v1/trades/' + tradeId + '/decline',
+      options: {
+        method: 'POST',
+        resolveWithFullResponse: true,
+        jar: jar,
+        headers: {
+          'X-CSRF-TOKEN': xcsrf,
+          'Content-Type': 'application/json'
+        }
+      }
+    }).then((res) => {
+      if (res.statusCode === 200) {
+        resolve()
+      } else {
+        const body = JSON.parse(res.body) || {}
+
+        if (body.errors && body.errors.length > 0) {
+          const errors = body.errors.map((e) => {
+            return e.message
+          })
+          reject(new Error(`${res.statusCode} ${errors.join(', ')}`))
+        }
+      }
+    }).catch(error => reject(error))
+  })
+}
+
+exports.func = function (args) {
+  const jar = args.jar
+  return getGeneralToken({ jar: jar })
+    .then(function (xcsrf) {
+      return declineTrade(args.tradeId, jar, xcsrf)
+    })
+}

package/lib/trades/getTradeInfo.js

@@ -0,0 +1,52 @@
+// Includes
+const http = require('../util/http.js').func
+
+// Args
+exports.required = ['tradeId']
+exports.optional = ['jar']
+
+// Docs
+/**
+ * 🔐 Get detailed information for a specific trade.
+ * @category Trade
+ * @alias getTradeInfo
+ * @param {number} tradeId - The id of the trade.
+ * @returns {Promise<TradeInfo>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const tradeInfo = await noblox.getTradeInfo(1234)
+**/
+
+// Define
+const getTradeInfo = (jar, tradeId) => {
+  return new Promise((resolve, reject) => {
+    http({
+      url: '//trades.roblox.com/v1/trades/' + tradeId,
+      options: {
+        method: 'GET',
+        resolveWithFullResponse: true,
+        jar: jar
+      }
+    }).then((res) => {
+      if (res.statusCode === 200) {
+        const body = JSON.parse(res.body)
+        body.created = new Date(body.created)
+        if (body.expiration) body.expiration = new Date(body.expiration)
+
+        resolve(body)
+      } else {
+        const body = JSON.parse(res.body) || {}
+        if (body.errors && body.errors.length > 0) {
+          const errors = body.errors.map((e) => {
+            return e.message
+          })
+          reject(new Error(`${res.statusCode} ${errors.join(', ')}`))
+        }
+      }
+    }).catch(error => reject(error))
+  })
+}
+
+exports.func = (args) => {
+  return getTradeInfo(args.jar, args.tradeId)
+}

package/lib/trades/getTrades.js

@@ -0,0 +1,37 @@
+// Includes
+const getPageResults = require('../util/getPageResults.js').func
+
+// Args
+exports.required = ['tradeStatusType']
+exports.optional = ['sortOrder', 'limit', 'jar']
+
+// Docs
+/**
+ * 🔐 Get the trades for a specific category.
+ * @category Trade
+ * @alias getTrades
+ * @param {string} tradeStatusType - The status of the trades to get [Inbound, Outbound, Complete, Inactive].
+ * @param {SortOrder=} [sortOrder=Asc] - The order that the data will be returned in (Asc or Desc)
+ * @param {Limit=} [limit=10] - The number of assets returned in each request (10, 25, 50, or 100)
+ * @returns {Promise<TradeAsset[]>}
+ * @example const noblox = require("noblox.js")
+ * // Login using your cookie
+ * const trades = await noblox.getTrades("Inbound")
+**/
+
+// Define
+exports.func = function (args) {
+  return getPageResults({
+    jar: args.jar,
+    url: `//trades.roblox.com/v1/trades/${args.tradeStatusType}`,
+    sortOrder: args.sortOrder,
+    limit: args.limit
+  }).then(function (results) {
+    results.forEach(result => {
+      result.created = new Date(result.created)
+      if (result.expiration) result.expiration = new Date(result.expiration)
+    })
+
+    return results
+  })
+}