[WIP] v3

lib/assets.js

@@ -1,20 +1,25 @@
 "use strict";
 
-const TradeOfferManager = require('./index.js');
-const Async = require('async');
 const EconItem = require('./classes/EconItem.js');
+const Helpers = require('./helpers.js');
+const TradeOfferManager = require('./index.js');
 
 const ITEMS_PER_CLASSINFO_REQUEST = 100;
 
+/**
+ * Stores item descriptions in the internal description cache.
+ * @param {Object[]|Object} descriptions
+ * @private
+ */
 TradeOfferManager.prototype._digestDescriptions = function(descriptions) {
-	var cache = this._assetCache;
+	let cache = this._assetCache;
 
 	if (!this._language) {
 		return;
 	}
 
-	if (descriptions && !(descriptions instanceof Array)) {
-		descriptions = Object.keys(descriptions).map(key => descriptions[key]);
+	if (descriptions && !Array.isArray(descriptions)) {
+		descriptions = Object.values(descriptions);
 	}
 
 	(descriptions || []).forEach((item) => {
@@ -27,19 +32,28 @@ TradeOfferManager.prototype._digestDescriptions = function(descriptions) {
 	});
 };
 
+/**
+ * Attaches item descriptions to some items from our internal description cache.
+ * Does not request missing descriptions.
+ * @param {int|null} appid
+ * @param {int|null} contextid
+ * @param {Object[]|Object} items
+ * @returns {EconItem[]}
+ * @private
+ */
 TradeOfferManager.prototype._mapItemsToDescriptions = function(appid, contextid, items) {
-	var cache = this._assetCache;
+	let cache = this._assetCache;
 
-	if (!(items instanceof Array)) {
-		items = Object.keys(items).map(key => items[key]);
+	if (!Array.isArray(items)) {
+		items = Object.values(items);
 	}
 
 	return items.map((item) => {
 		item.appid = appid || item.appid;
 		item.contextid = contextid || item.contextid;
 
-		var key = `${item.appid}_${item.classid}_${item.instanceid || '0'}`;
-		var entry = cache.get(key);
+		let key = `${item.appid}_${item.classid}_${item.instanceid || '0'}`;
+		let entry = cache.get(key);
 		if (!entry) {
 			// This item isn't in our description cache
 			return new EconItem(item);
@@ -55,150 +69,151 @@ TradeOfferManager.prototype._mapItemsToDescriptions = function(appid, contextid,
 	});
 };
 
+/**
+ * Checks whether we have a description for a given item in our cache.
+ * @param {{appid?: int, classid: int|string, instanceid?: int|string}} item
+ * @param {int} [appid]
+ * @returns {boolean}
+ * @private
+ */
 TradeOfferManager.prototype._hasDescription = function(item, appid) {
 	appid = appid || item.appid;
 	return !!this._assetCache.get(appid + '_' + item.classid + '_' + (item.instanceid || '0'));
 };
 
-TradeOfferManager.prototype._addDescriptions = function(items, callback) {
-	var descriptionRequired = items.filter(item => !this._hasDescription(item));
-
-	if (descriptionRequired.length == 0) {
-		callback(null, this._mapItemsToDescriptions(null, null, items));
+/**
+ * Requests descriptions for a set of classes from the API.
+ * @param {{appid: int, classid: int|string, instanceid?: int|string}[]} classes
+ * @returns {Promise}
+ * @private
+ */
+TradeOfferManager.prototype._requestDescriptions = async function(classes) {
+	if (!this._language) {
 		return;
 	}
 
-	this._requestDescriptions(descriptionRequired, (err) => {
-		if (err) {
-			callback(err);
-		} else {
-			callback(null, this._mapItemsToDescriptions(null, null, items));
+	// Filter out any classes we already have descriptions for
+	classes = classes.filter(cls => !this._hasDescription(cls));
+	// Filter out any duplicate classes
+	classes = classes.filter((cls, idx) => classes.findIndex(cls2 => Helpers.classEquals(cls, cls2)) === idx);
+
+	if (classes.length == 0) {
+		return; // nothing to request
+	}
+
+	// Get whatever we can from disk
+	let filenames = classes.map(item => `asset_${item.appid}_${item.classid}_${item.instanceid || '0'}.json`);
+	let files = await this._getFromDisk(filenames); // _getFromDisk never rejects
+	for (let filename in files) {
+		let match = filename.match(/asset_(\d+_\d+_\d+)\.json/);
+		if (!match) {
+			this.emit('debug', `Shouldn't be possible, but filename ${filename} doesn't match regex`);
+			continue; // shouldn't be possible
 		}
-	});
-};
 
-TradeOfferManager.prototype._requestDescriptions = function(classes, callback) {
-	var getFromSteam = () => {
-		var apps = [];
-		var appids = [];
+		try {
+			this._assetCache.add(match[1], JSON.parse(files[filename].toString('utf8')));
+		} catch (ex) {
+			this.emit('debug', `Error parsing description file ${filename}: ${ex.message}`);
+		}
+	}
 
-		// Split this out into appids
-		classes.forEach((item) => {
-			// Don't add this if we already have it in the cache
-			if (this._assetCache.get(`${item.appid}_${item.classid}_${item.instanceid || '0'}`)) {
-				return;
-			}
+	// get the rest from steam
+	let apps = [];
+	let appids = [];
 
-			var index = appids.indexOf(item.appid);
-			if (index == -1) {
-				index = appids.push(item.appid) - 1;
-				var arr = [];
-				arr.appid = item.appid;
-				apps.push(arr);
-			}
+	// Split this out into appids
+	classes.forEach((item) => {
+		// Don't add this if we already have it in the cache
+		if (this._assetCache.get(`${item.appid}_${item.classid}_${item.instanceid || '0'}`)) {
+			return;
+		}
 
-			// Don't add a class/instanceid pair that we already have in the list
-			if (apps[index].indexOf(item.classid + '_' + (item.instanceid || '0')) == -1) {
-				apps[index].push(item.classid + '_' + (item.instanceid || '0'));
-			}
-		});
+		let index = appids.indexOf(item.appid);
+		if (index == -1) {
+			index = appids.push(item.appid) - 1;
+			let arr = [];
+			arr.appid = item.appid;
+			apps.push(arr);
+		}
+
+		// Don't add a class/instanceid pair that we already have in the list
+		if (apps[index].indexOf(item.classid + '_' + (item.instanceid || '0')) == -1) {
+			apps[index].push(item.classid + '_' + (item.instanceid || '0'));
+		}
+	});
 
-		Async.map(apps, (app, cb) => {
-			var chunks = [];
-			var items = [];
+	let appPromises = [];
+	apps.forEach((app) => {
+		appPromises.push(new Promise(async (resolve, reject) => {
+			let chunks = [];
 
 			// Split this into chunks of ITEMS_PER_CLASSINFO_REQUEST items
 			while (app.length > 0) {
 				chunks.push(app.splice(0, ITEMS_PER_CLASSINFO_REQUEST));
 			}
 
-			Async.each(chunks, (chunk, chunkCb) => {
-				var input = {
-					"appid": app.appid,
-					"language": this._language,
-					"class_count": chunk.length
-				};
-
-				chunk.forEach((item, index) => {
-					var parts = item.split('_');
-					input['classid' + index] = parts[0];
-					input['instanceid' + index] = parts[1];
-				});
-
-				this.emit('debug', "Requesting classinfo for " + chunk.length + " items from app " + app.appid);
-				this._apiCall('GET', {
-					"iface": "ISteamEconomy",
-					"method": "GetAssetClassInfo"
-				}, 1, input, (err, body) => {
-					if (err) {
-						chunkCb(err);
-						return;
-					}
-
-					if (!body.result || !body.result.success) {
-						chunkCb(new Error("Invalid API response"));
-						return;
-					}
-
-					var chunkItems = Object.keys(body.result).map((id) => {
-						if (!id.match(/^\d+(_\d+)?$/)) {
-							return null;
+			let chunkPromises = [];
+			chunks.forEach((chunk) => {
+				chunkPromises.push(new Promise(async (resolve, reject) => {
+					let input = {
+						appid: app.appid,
+						language: this._language,
+						class_count: chunk.length
+					};
+
+					chunk.forEach((item, index) => {
+						let parts = item.split('_');
+						input['classid' + index] = parts[0];
+						input['instanceid' + index] = parts[1];
+					});
+
+					try {
+						this.emit('debug', `Requesting classinfo for ${chunk.length} items from app ${app.appid}`);
+						let body = await this._apiCall('GET', {iface: 'ISteamEconomy', method: 'GetAssetClassInfo'}, 1, input);
+						if (!body.result || !body.result.success) {
+							return reject(new Error('Invalid API response'));
 						}
 
-						var item = body.result[id];
-						item.appid = app.appid;
-						return item;
-					}).filter(item => !!item);
-
-					items = items.concat(chunkItems);
-
-					chunkCb(null);
-				});
-			}, (err) => {
-				if (err) {
-					cb(err);
-				} else {
-					cb(null, items);
-				}
-			});
-		}, (err, result) => {
-			if (err) {
-				callback(err);
-				return;
-			}
-
-			result.forEach(this._digestDescriptions.bind(this));
-			callback();
-		});
-	};
-
-	// Get whatever we can from disk
-	var filenames = classes.map(item => `asset_${item.appid}_${item.classid}_${item.instanceid || '0'}.json`);
-	this._getFromDisk(filenames, (err, files) => {
-		if (err) {
-			getFromSteam();
-			return;
-		}
+						let chunkItems = Object.keys(body.result).map((id) => {
+							if (!id.match(/^\d+(_\d+)?$/)) {
+								return null;
+							}
 
-		for (var filename in files) {
-			if (!files.hasOwnProperty(filename)) {
-				continue;
-			}
+							let item = body.result[id];
+							item.appid = app.appid;
+							return item;
+						}).filter(item => !!item);
 
-			var match = filename.match(/asset_(\d+_\d+_\d+)\.json/);
-			if (!match) {
-				this.emit('debug', "Shouldn't be possible, but filename " + filename + " doesn't match regex");
-				continue; // shouldn't be possible
-			}
+						this._digestDescriptions(chunkItems);
+						resolve();
+					} catch (ex) {
+						return reject(ex);
+					}
+				}));
+			});
 
 			try {
-				this._assetCache.add(match[1], JSON.parse(files[filename].toString('utf8')));
+				await Promise.all(chunkPromises);
 			} catch (ex) {
-				this.emit('debug', "Error parsing description file " + filename + ": " + ex);
+				return reject(ex);
 			}
-		}
 
-		// get the rest from steam
-		getFromSteam();
+			resolve();
+		}));
 	});
+
+	await Promise.all(appPromises);
+};
+
+/**
+ * Requests descriptions (if missing) for items in some trade offers.
+ * @param {{items_to_give?: Object[], items_to_receive?: Object[]}[]} offers
+ * @returns {Promise}
+ * @private
+ */
+TradeOfferManager.prototype._requestDescriptionsForOffers = async function(offers) {
+	let items = [];
+	offers.forEach((offer) => items = items.concat(offer.items_to_give || []).concat(offer.items_to_receive || []));
+	return await this._requestDescriptions(items);
 };