3.11.1

Fixed error on getNotifications

classes/CEconItem.js

@@ -0,0 +1,59 @@
+module.exports = CEconItem;
+
+function CEconItem(item, descriptions, contextID) {
+	var thing;
+	for(thing in item) {
+		if(item.hasOwnProperty(thing)) {
+			this[thing] = item[thing];
+		}
+	}
+
+	this.assetid = this.id = (this.id || this.assetid);
+	this.instanceid = this.instanceid || '0';
+	this.amount = parseInt(this.amount, 10);
+	this.contextid = this.contextid || contextID.toString();
+
+	// Merge the description
+	if(descriptions) {
+		var description = descriptions[this.classid + '_' + this.instanceid];
+		if(description) {
+			for(thing in description) {
+				if(description.hasOwnProperty(thing)) {
+					this[thing] = description[thing];
+				}
+			}
+		}
+	}
+
+	this.tradable = !!this.tradable;
+	this.marketable = !!this.marketable;
+	this.commodity = !!this.commodity;
+	this.market_tradable_restriction = (this.market_tradable_restriction ? parseInt(this.market_tradable_restriction, 10) : 0);
+	this.market_marketable_restriction = (this.market_marketable_restriction ? parseInt(this.market_marketable_restriction, 10) : 0);
+}
+
+CEconItem.prototype.getImageURL = function() {
+	return "https://steamcommunity-a.akamaihd.net/economy/image/" + this.icon_url + "/";
+};
+
+CEconItem.prototype.getLargeImageURL = function() {
+	if(!this.icon_url_large) {
+		return this.getImageURL();
+	}
+
+	return "https://steamcommunity-a.akamaihd.net/economy/image/" + this.icon_url_large + "/";
+};
+
+CEconItem.prototype.getTag = function(category) {
+	if(!this.tags) {
+		return null;
+	}
+
+	for(var i = 0; i < this.tags.length; i++) {
+		if(this.tags[i].category == category) {
+			return this.tags[i];
+		}
+	}
+
+	return null;
+};

classes/CSteamUser.js

@@ -40,6 +40,11 @@ SteamCommunity.prototype.getSteamUser = function(id, callback) {
 					customurl = match[1];
 				}
 			}
+
+			if(!result.profile.steamID64) {
+				callback(new Error("No valid response"));
+				return;
+			}
 			
 			callback(null, new CSteamUser(self, result.profile, customurl));
 		});
@@ -50,22 +55,26 @@ function CSteamUser(community, userData, customurl) {
 	this._community = community;
 	
 	this.steamID = new SteamID(userData.steamID64[0]);
-	this.name = userData.steamID[0];
-	this.onlineState = userData.onlineState[0];
-	this.stateMessage = userData.stateMessage[0];
-	this.privacyState = userData.privacyState[0];
-	this.visibilityState = userData.visibilityState[0];
-	this.avatarHash = userData.avatarIcon[0].match(/([0-9a-f]+)\.[a-z]+$/)[1];
-	this.vacBanned = !!userData.vacBanned[0];
-	this.tradeBanState = userData.tradeBanState[0];
-	this.isLimitedAccount = !!userData.isLimitedAccount[0];
-	this.customURL = userData.customURL ? userData.customURL[0] : customurl;
+	this.name = processItem('steamID');
+	this.onlineState = processItem('onlineState');
+	this.stateMessage = processItem('stateMessage');
+	this.privacyState = processItem('privacyState', 'uncreated');
+	this.visibilityState = processItem('visibilityState');
+	this.avatarHash = processItem('avatarIcon', '').match(/([0-9a-f]+)\.[a-z]+$/);
+	if(this.avatarHash) {
+		this.avatarHash = this.avatarHash[1];
+	}
+
+	this.vacBanned = processItem('vacBanned', false) == 1;
+	this.tradeBanState = processItem('tradeBanState', 'None');
+	this.isLimitedAccount = processItem('isLimitedAccount') == 1;
+	this.customURL = processItem('customURL', customurl);
 	
 	if(this.visibilityState == 3) {
-		this.memberSince = new Date(userData.memberSince[0].replace(/(\d{1,2})(st|nd|th)/, "$1"));
-		this.location = userData.location[0] || null;
-		this.realName = userData.realname[0] || null;
-		this.summary = userData.summary[0] || null;
+		this.memberSince = new Date(processItem('memberSince', '0').replace(/(\d{1,2})(st|nd|th)/, "$1"));
+		this.location = processItem('location');
+		this.realName = processItem('realname');
+		this.summary = processItem('summary');
 	} else {
 		this.memberSince = null;
 		this.location = null;
@@ -88,6 +97,14 @@ function CSteamUser(community, userData, customurl) {
 			return new SteamID(group.groupID64[0]);
 		});
 	}
+
+	function processItem(name, defaultVal) {
+		if(!userData[name]) {
+			return defaultVal;
+		}
+
+		return userData[name][0];
+	}
 }
 
 CSteamUser.getAvatarURL = function(hash, size, protocol) {
@@ -134,3 +151,11 @@ CSteamUser.prototype.comment = function(message, callback) {
 CSteamUser.prototype.inviteToGroup = function(groupID, callback) {
 	this._community.inviteUserToGroup(this.steamID, groupID, callback);
 };
+
+CSteamUser.prototype.getInventoryContexts = function(callback) {
+	this._community.getUserInventoryContexts(this.steamID, callback);
+};
+
+CSteamUser.prototype.getInventory = function(appID, contextID, tradableOnly, callback) {
+	this._community.getUserInventory(this.steamID, appID, contextID, tradableOnly, callback);
+};

components/chat.js

@@ -40,17 +40,9 @@ SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
 	this.chatState = SteamCommunity.ChatState.LoggingOn;
 	
 	var self = this;
-	this.request("https://steamcommunity.com/chat", function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			self.emit('debug', 'Error requesting chat WebAPI token: ' + (err ? err.message : "HTTP error " + response.statusCode));
-			self.chatState = SteamCommunity.ChatState.LogOnFailed;
-			setTimeout(self.chatLogon.bind(self), 5000);
-			return;
-		}
-		
-		var match = body.match(/[0-9a-f]{32}/);
-		if(!match) {
-			self.emit('debug', 'Couldn\'t find a WebAPI chat token in the response.');
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			self.emit('debug', "Cannot get oauth token: " + err.message);
 			self.chatState = SteamCommunity.ChatState.LogOnFailed;
 			setTimeout(self.chatLogon.bind(self), 5000);
 			return;
@@ -60,7 +52,7 @@ SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
 			"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Logon/v1",
 			"form": {
 				"ui_mode": uiMode,
-				"access_token": match[0]
+				"access_token": token
 			},
 			"json": true
 		}, function(err, response, body) {
@@ -81,7 +73,7 @@ SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
 			self._chat = {
 				"umqid": body.umqid,
 				"message": body.message,
-				"accessToken": match[0],
+				"accessToken": token,
 				"interval": interval
 			};
 			

components/groups.js

@@ -203,7 +203,7 @@ SteamCommunity.prototype.scheduleGroupEvent = function(gid, name, type, descript
 
 	var self = this;
 	this.request.post({
-		"uri": "https://steamcommunity.com/gid/" + this.steamID.toString() + "/eventEdit",
+		"uri": "https://steamcommunity.com/gid/" + gid.toString() + "/eventEdit",
 		"form": form
 	}, function(err, response, body) {
 		if(!callback) {

components/inventoryhistory.js

@@ -0,0 +1,141 @@
+var SteamCommunity = require('../index.js');
+var CEconItem = require('../classes/CEconItem.js');
+var SteamID = require('steamid');
+var request = require('request');
+var Cheerio = require('cheerio');
+var Async = require('async');
+
+SteamCommunity.prototype.getInventoryHistory = function(options, callback) {
+	if(typeof options === 'function') {
+		callback = options;
+		options = {};
+	}
+	
+	options.page = options.page || 1;
+	
+	this.request("https://steamcommunity.com/my/inventoryhistory?l=english&p=" + options.page, function(err, response, body) {
+		if(err) {
+			callback(err);
+			return;
+		}
+		
+		var output = {};
+		var vanityURLs = [];
+		
+		var $ = Cheerio.load(body);
+		var html = $('.inventory_history_pagingrow').html();
+		if(!html) {
+			callback("Malformed page: no paging row found");
+			return;
+		}
+		
+		var match = html.match(/(\d+) - (\d+) of (\d+) History Items/);
+		
+		output.first = parseInt(match[1], 10);
+		output.last = parseInt(match[2], 10);
+		output.totalTrades = parseInt(match[3], 10);
+		
+		// Load the inventory item data
+		var match2 = body.match(/var g_rgHistoryInventory = (.*);/);
+		if(!match2) {
+			callback(new Error("Malformed page: no trade found"));
+			return;
+		}
+		var historyInventory = JSON.parse(match2[1]);
+		
+		output.trades = [];
+		var trades = $('.tradehistoryrow');
+		
+		var item, trade, profileLink, items, j, econItem, timeMatch, time;
+		for(var i = 0; i < trades.length; i++) {
+			item = $(trades[i]);
+			trade = {};
+			
+			timeMatch = item.find('.tradehistory_timestamp').html().match(/(\d+):(\d+)(am|pm)/);
+			if(timeMatch[1] == 12 && timeMatch[3] == 'am') {
+				timeMatch[1] = 0;
+			}
+			
+			if(timeMatch[1] < 12 && timeMatch[3] == 'pm') {
+				timeMatch[1] = parseInt(timeMatch[1], 10) + 12;
+			}
+			
+			time = (timeMatch[1] < 10 ? '0' : '') + timeMatch[1] + ':' + timeMatch[2] + ':00';
+			
+			trade.date = new Date(item.find('.tradehistory_date').html() + ' ' + time);
+			trade.partnerName = item.find('.tradehistory_event_description a').html();
+			trade.partnerSteamID = null;
+			trade.partnerVanityURL = null;
+			trade.itemsReceived = [];
+			trade.itemsGiven = [];
+			
+			profileLink = item.find('.tradehistory_event_description a').attr('href');
+			if(profileLink.indexOf('/profiles/') != -1) {
+				trade.partnerSteamID = new SteamID(profileLink.match(/(\d+)$/)[1]);
+			} else {
+				trade.partnerVanityURL = profileLink.match(/\/([^\/]+)$/)[1];
+				if(options.resolveVanityURLs && vanityURLs.indexOf(trade.partnerVanityURL) == -1) {
+					vanityURLs.push(trade.partnerVanityURL);
+				}
+			}
+			
+			items = item.find('.history_item');
+			for(j = 0; j < items.length; j++) {
+				match = body.match(new RegExp("HistoryPageCreateItemHover\\( '" + $(items[j]).attr('id') + "', (\\d+), '(\\d+)', '(\\d+)', '(\\d+)' \\);"));
+				econItem = historyInventory[match[1]][match[2]][match[3]];
+				
+				if($(items[j]).attr('id').indexOf('received') != -1) {
+					trade.itemsReceived.push(new CEconItem(econItem));
+				} else {
+					trade.itemsGiven.push(new CEconItem(econItem));
+				}
+			}
+			
+			output.trades.push(trade);
+		}
+		
+		if(options.resolveVanityURLs) {
+			Async.map(vanityURLs, resolveVanityURL, function(err, results) {
+				if(err) {
+					callback(err);
+					return;
+				}
+				
+				for(i = 0; i < output.trades.length; i++) {
+					if(output.trades[i].partnerSteamID || !output.trades[i].partnerVanityURL) {
+						continue;
+					}
+					
+					// Find the vanity URL
+					for(j = 0; j < results.length; j++) {
+						if(results[j].vanityURL == output.trades[i].partnerVanityURL) {
+							output.trades[i].partnerSteamID = new SteamID(results[j].steamID);
+							break;
+						}
+					}
+				}
+				
+				callback(null, output);
+			});
+		} else {
+			callback(null, output);
+		}
+	});
+};
+
+function resolveVanityURL(vanityURL, callback) {
+	request("https://steamcommunity.com/id/" + vanityURL + "/?xml=1", function(err, response, body) {
+		if(err) {
+			callback(err);
+			return;
+		}
+		
+		var match = body.match(/<steamID64>(\d+)<\/steamID64>/);
+		if(!match || !match[1]) {
+			callback(new Error("Couldn't find Steam ID"));
+			return;
+		}
+		
+		callback(null, {"vanityURL": vanityURL, "steamID": match[1]});
+	});
+}

components/profile.js

@@ -101,10 +101,10 @@ SteamCommunity.prototype.editProfile = function(settings, callback) {
 					break;
 				
 				case 'primaryGroup':
-					if(typeof settings[i] === 'object' && settings[i].accountid) {
-						values.primary_group_steamid = settings[i].accountid;
+					if(typeof settings[i] === 'object' && settings[i].getSteamID64) {
+						values.primary_group_steamid = settings[i].getSteamID64();
 					} else {
-						values.primary_group_steamid = new SteamID(settings[i]).accountid;
+						values.primary_group_steamid = new SteamID(settings[i]).getSteamID64();
 					}
 					
 					break;

components/twofactor.js

@@ -0,0 +1,160 @@
+var SteamTotp = require('steam-totp');
+var SteamCommunity = require('../index.js');
+
+var ETwoFactorTokenType = {
+	"None": 0,                  // No token-based two-factor authentication
+	"ValveMobileApp": 1,        // Tokens generated using Valve's special charset (5 digits, alphanumeric)
+	"ThirdParty": 2             // Tokens generated using literally everyone else's standard charset (6 digits, numeric). This is disabled.
+};
+
+SteamCommunity.prototype.enableTwoFactor = function(callback) {
+	var self = this;
+
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		// Create a random device ID hash
+		var hash = require('crypto').createHash('sha1');
+		hash.update(Math.random().toString());
+		hash = hash.digest('hex');
+
+		self.request.post({
+			"uri": "https://api.steampowered.com/ITwoFactorService/AddAuthenticator/v1/",
+			"form": {
+				"steamid": self.steamID.getSteamID64(),
+				"access_token": token,
+				"authenticator_time": Math.floor(Date.now() / 1000),
+				"authenticator_type": ETwoFactorTokenType.ValveMobileApp,
+				"device_identifier": 'android:' + hash,
+				"sms_phone_id": "1"
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body.response) {
+				callback(new Error("Malformed response"));
+				return;
+			}
+
+			if(body.response.status != 1) {
+				var error = new Error("Error " + body.response.status);
+				error.eresult = body.response.status;
+				callback(error);
+				return;
+			}
+
+			callback(null, body.response);
+		});
+	});
+};
+
+SteamCommunity.prototype.finalizeTwoFactor = function(secret, activationCode, callback) {
+	var attemptsLeft = 30;
+	var diff = 0;
+
+	var self = this;
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		finalize(token);
+	});
+
+	function finalize(token) {
+		var code = SteamTotp.generateAuthCode(secret, diff);
+
+		self.request.post({
+			"uri": "https://api.steampowered.com/ITwoFactorService/FinalizeAddAuthenticator/v1/",
+			"form": {
+				"steamid": self.steamID.getSteamID64(),
+				"access_token": token,
+				"authenticator_code": code,
+				"authenticator_time": Math.floor(Date.now() / 1000),
+				"activation_code": activationCode
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body.response) {
+				callback(new Error("Malformed response"));
+				return;
+			}
+
+			body = body.response;
+			console.log(body);
+
+			if(body.server_time) {
+				diff = body.server_time - Math.floor(Date.now() / 1000);
+			}
+
+			if(body.status == 89) {
+				callback(new Error("Invalid activation code"));
+			} else if(!body.success) {
+				callback(new Error("Error " + body.status));
+			} else if(body.want_more) {
+				attemptsLeft--;
+				diff += 30;
+
+				finalize(token);
+			} else {
+				callback(null);
+			}
+		});
+	}
+};
+
+SteamCommunity.prototype.disableTwoFactor = function(revocationCode, callback) {
+	var self = this;
+
+	this.getWebApiOauthToken(function(err, token) {
+		if(err) {
+			callback(err);
+			return;
+		}
+
+		self.request.post({
+			"uri": "https://api.steampowered.com/ITwoFactorService/RemoveAuthenticator/v1/",
+			"form": {
+				"steamid": self.steamID.getSteamID64(),
+				"access_token": token,
+				"revocation_code": revocationCode,
+				"steamguard_scheme": 1
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body.response) {
+				callback(new Error("Malformed response"));
+				return;
+			}
+
+			if(!body.response.success) {
+				callback(new Error("Request failed"));
+				return;
+			}
+
+			if(body.response.status == 1) {
+				callback(null);
+				return;
+			}
+
+			var error = new Error("Cannot remove authenticator (" + body.response.status + ")");
+			error.eresult = body.response.status;
+			callback(error);
+		});
+	});
+};

components/users.js

@@ -1,5 +1,6 @@
 var SteamCommunity = require('../index.js');
 var SteamID = require('steamid');
+var CEconItem = require('../classes/CEconItem.js');
 
 SteamCommunity.prototype.addFriend = function(userID, callback) {
 	if(typeof userID === 'string') {
@@ -155,7 +156,7 @@ SteamCommunity.prototype.postUserComment = function(userID, message, callback) {
 
 		if(body.success) {
 			callback(null);
-		} else if(bpdy.error) {
+		} else if(body.error) {
 			callback(new Error(body.error));
 		} else {
 			callback(new Error("Unknown error"));
@@ -197,3 +198,101 @@ SteamCommunity.prototype.inviteUserToGroup = function(userID, groupID, callback)
 		}
 	});
 };
+
+SteamCommunity.prototype.getUserInventoryContexts = function(userID, callback) {
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	if(typeof userID === 'function') {
+		callback = userID;
+		userID = this.steamID;
+	}
+
+	if(!userID) {
+		callback(new Error("No SteamID specified and not logged in"));
+		return;
+	}
+
+	var self = this;
+	this.request("https://steamcommunity.com/profiles/" + userID.getSteamID64() + "/inventory/", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		var match = body.match(/var g_rgAppContextData = ([^\n]+);\r?\n/);
+		if(!match) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		var data;
+		try {
+			data = JSON.parse(match[1]);
+		} catch(e) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		callback(null, data);
+	});
+};
+
+SteamCommunity.prototype.getUserInventory = function(userID, appID, contextID, tradableOnly, callback) {
+	var self = this;
+
+	if(typeof userID === 'string') {
+		userID = new SteamID(userID);
+	}
+
+	var endpoint = "/profiles/" + userID.getSteamID64();
+	get([], []);
+
+	function get(inventory, currency, start) {
+		self.request({
+			"uri": "https://steamcommunity.com" + endpoint + "/inventory/json/" + appID + "/" + contextID,
+			"qs": {
+				"start": start,
+				"trading": tradableOnly ? 1 : undefined
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
+				return;
+			}
+
+			if(!body || !body.success || !body.rgInventory || !body.rgDescriptions || !body.rgCurrency) {
+				callback(new Error(body.Error || "Malformed response"));
+				return;
+			}
+
+			var i;
+			for(i in body.rgInventory) {
+				if(!body.rgInventory.hasOwnProperty(i)) {
+					continue;
+				}
+
+				inventory.push(new CEconItem(body.rgInventory[i], body.rgDescriptions, contextID));
+			}
+
+			for(i in body.rgCurrency) {
+				if(!body.rgCurrency.hasOwnProperty(i)) {
+					continue;
+				}
+
+				currency.push(new CEconItem(body.rgInventory[i], body.rgDescriptions, contextID));
+			}
+
+			if(body.more) {
+				var match = response.request.uri.href.match(/\/(profiles|id)\/([^\/]+)\//);
+				if(match) {
+					endpoint = "/" + match[1] + "/" + match[2];
+				}
+
+				get(inventory, currency, body.more_start);
+			} else {
+				callback(null, inventory, currency);
+			}
+		});
+	}
+};

components/webapi.js

@@ -0,0 +1,20 @@
+var SteamCommunity = require('../index.js');
+
+SteamCommunity.prototype.getWebApiOauthToken = function(callback) {
+	var self = this;
+
+	// Pull an oauth token from the webchat UI
+	this.request("https://steamcommunity.com/chat", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		var match = body.match(/"([0-9a-f]{32})"/);
+		if (!match) {
+			callback(new Error("Malformed response"));
+			return;
+		}
+
+		callback(null, match[1]);
+	});
+};

index.js

@@ -145,7 +145,7 @@ SteamCommunity.prototype.getSessionID = function() {
 
 function generateSessionID() {
 	return Math.floor(Math.random() * 1000000000);
-};
+}
 
 SteamCommunity.prototype.getWebApiKey = function(domain, callback) {
 	var self = this;
@@ -158,7 +158,7 @@ SteamCommunity.prototype.getWebApiKey = function(domain, callback) {
 		}
 		
 		if(body.match(/<h2>Access Denied<\/h2>/)) {
-			return callback("Access Denied");
+			return callback(new Error("Access Denied"));
 		}
 		
 		var match = body.match(/<p>Key: ([0-9A-F]+)<\/p>/);
@@ -213,6 +213,7 @@ SteamCommunity.prototype.parentalUnlock = function(pin, callback) {
 };
 
 SteamCommunity.prototype.getNotifications = function(callback) {
+	var self = this;
 	this.request.get("https://steamcommunity.com/actions/RefreshNotificationArea", function(err, response, body) {
 		if(self._checkHttpError(err, response, callback)) {
 			return;
@@ -331,6 +332,9 @@ require('./components/profile.js');
 require('./components/market.js');
 require('./components/groups.js');
 require('./components/users.js');
+require('./components/inventoryhistory.js');
+require('./components/webapi.js');
+require('./components/twofactor.js');
 require('./classes/CMarketItem.js');
 require('./classes/CMarketSearchResult.js');
 require('./classes/CSteamGroup.js');

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "steamcommunity",
-	"version": "3.7.2",
+	"version": "3.11.1",
 	"description": "Provides an interface for logging into and interacting with the Steam Community website",
 	"keywords": ["steam", "steam community"],
 	"homepage": "https://github.com/DoctorMcKay/node-steamcommunity",
@@ -17,6 +17,8 @@
 		"node-bignumber":	"^1.2.1",
 		"steamid":			"^0.3.1",
 		"xml2js":			"^0.4.11",
-		"cheerio":			"^0.19.0"
+		"cheerio":			"^0.19.0",
+		"async":			"^1.4.2",
+		"steam-totp":		"^1.0.0"
 	}
 }