3.2.1

README.md

@@ -1,4 +1,4 @@
-simply # Steam Community for Node.js
+# Steam Community for Node.js
 
 This lightweight module provides an easy interface for the Steam Community website. This module can be used to simply login to steamcommunity.com for use with other libraries, or to interact with steamcommunity.com.
 

classes/CMarketItem.js

@@ -0,0 +1,126 @@
+var SteamCommunity = require('../index.js');
+var Cheerio = require('cheerio');
+
+SteamCommunity.prototype.getMarketItem = function(appid, hashName, callback) {
+	var self = this;
+	this.request("https://steamcommunity.com/market/listings/" + appid + "/" + encodeURIComponent(hashName), function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		var $ = Cheerio.load(body);
+		if($('.market_listing_table_message') && $('.market_listing_table_message').text().trim() == 'There are no listings for this item.') {
+			callback(new Error("There are no listings for this item."));
+			return;
+		}
+		
+		var item = new CMarketItem(self, body, $);
+		if(item.commodity) {
+			item.updatePrice(function(err) {
+				if(err) {
+					callback(err);
+				} else {
+					callback(null, item);
+				}
+			});
+		} else {
+			callback(null, item);
+		}
+	});
+};
+
+function CMarketItem(community, body, $) {
+	this._community = community;
+	this._$ = $;
+	
+	this._country = "US";
+	var match = body.match(/var g_strCountryCode = "([^"]+)";/);
+	if(match) {
+		this._country = match[1];
+	}
+	
+	this.commodity = false;
+	var match = body.match(/Market_LoadOrderSpread\(\s*(\d+)\s*\);/);
+	if(match) {
+		this.commodity = true;
+		this.commodityID = parseInt(match[1], 10);
+	}
+	
+	this.medianSalePrices = null;
+	match = body.match(/var line1=([^;]+);/);
+	if(match) {
+		try {
+			this.medianSalePrices = JSON.parse(match[1]);
+			this.medianSalePrices = this.medianSalePrices.map(function(item) {
+				return {
+					"hour": new Date(item[0]),
+					"price": item[1],
+					"quantity": parseInt(item[2], 10)
+				};
+			});
+		} catch(e) {
+			// ignore
+		}
+	}
+	
+	this.quantity = 0;
+	this.lowestPrice = 0;
+	
+	if(!this.commodity) {
+		var total = $('#searchResults_total');
+		if(total) {
+			this.quantity = parseInt(total.text().replace(/[^\d]/g, '').trim(), 10);
+		}
+		
+		var lowest = $('.market_listing_price.market_listing_price_with_fee');
+		if(lowest[0]) {
+			this.lowestPrice = parseInt($(lowest[0]).text().replace(/[^\d]/g, '').trim(), 10);
+		}
+	}
+	
+	// TODO: Buying listings and placing buy orders
+}
+
+CMarketItem.prototype.updatePrice = function(callback) {
+	if(!this.commodity) {
+		throw new Error("Cannot update price for non-commodity item");
+	}
+	
+	// TODO: Currency option maybe?
+	var self = this;
+	this._community.request({
+		"uri": "https://steamcommunity.com/market/itemordershistogram?country=US&language=english&currency=1&item_nameid=" + this.commodityID,
+		"json": true,
+	}, function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		if(body.success != 1) {
+			if(callback) {
+				callback(new Error("Error " + body.success));
+			}
+			
+			return;
+		}
+		
+		var match = (body.sell_order_summary || '').match(/<span class="market_commodity_orders_header_promote">(\d+)<\/span>/);
+		if(match) {
+			self.quantity = parseInt(match[1], 10);
+		}
+		
+		self.buyQuantity = 0;
+		match = (body.buy_order_summary || '').match(/<span class="market_commodity_orders_header_promote">(\d+)<\/span>/);
+		if(match) {
+			self.buyQuantity = parseInt(match[1], 10);
+		}
+		
+		self.lowestPrice = parseInt(body.lowest_sell_order, 10);
+		self.highestBuyOrder = parseInt(body.highest_buy_order, 10);
+		
+		// TODO: The tables?
+		if(callback) {
+			callback(null);
+		}
+	});
+};

classes/CMarketSearchResult.js

@@ -0,0 +1,84 @@
+var SteamCommunity = require('../index.js');
+var Cheerio = require('cheerio');
+
+SteamCommunity.prototype.marketSearch = function(options, callback) {
+	var qs = {};
+	
+	if(typeof options === 'string') {
+		qs.query = options;
+	} else {
+		qs.query = options.query || '';
+		qs.appid = options.appid;
+		qs.search_descriptions = options.searchDescriptions ? 1 : 0;
+		
+		if(qs.appid) {
+			for(var i in options) {
+				if(['query', 'appid', 'searchDescriptions'].indexOf(i) != -1) {
+					continue;
+				}
+				
+				// This is a tag
+				qs['category_' + qs.appid + '_' + i + '[]'] = 'tag_' + options[i];
+			}
+		}
+	}
+	
+	qs.start = 0;
+	qs.count = 100;
+	qs.sort_column = 'price';
+	qs.sort_dir = 'asc';
+	performSearch(this.request, qs, [], callback);
+};
+
+function performSearch(request, qs, results, callback) {
+	request({
+		"uri": "https://steamcommunity.com/market/search/render/",
+		"qs": qs,
+		"headers": {
+			"referer": "https://steamcommunity.com/market/search"
+		},
+		"json": true
+	}, function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		if(!body.success) {
+			callback(new Error("Success is not true"));
+			return;
+		}
+		
+		if(!body.results_html) {
+			callback(new Error("No results_html in response"));
+			return;
+		}
+		
+		var $ = Cheerio.load(body.results_html);
+		if($('.market_listing_table_message').length > 0) {
+			callback(new Error($('.market_listing_table_message').text()));
+			return;
+		}
+		
+		var rows = $('.market_listing_row_link');
+		for(var i = 0; i < rows.length; i++) {
+			results.push(new CMarketSearchResult($(rows[i])));
+		}
+		
+		if(body.start + body.pagesize >= body.total_count) {
+			callback(null, results);
+		} else {
+			qs.start += body.pagesize;
+			performSearch(request, qs, results, callback);
+		}
+	});
+}
+
+function CMarketSearchResult(row) {
+	var match = row.attr('href').match(/\/market\/listings\/(\d+)\/(.+)/);
+	
+	this.appid = parseInt(match[1], 10);
+	this.market_hash_name = decodeURIComponent(match[2]);
+	this.image = row.find('.market_listing_item_img').attr('src').match(/^https?:\/\/[^\/]+\/economy\/image\/[^\/]+\//)[0];
+	this.price = parseInt(row.find('.market_listing_their_price .market_table_value span').text().replace(/[^\d]+/g, ''), 10);
+	this.quantity = parseInt(row.find('.market_listing_num_listings_qty').text().replace(/[^\d]+/g, ''), 10);
+}

classes/CSteamGroup.js

@@ -12,9 +12,8 @@ SteamCommunity.prototype.getSteamGroup = function(id, callback) {
 	}
 	
 	var self = this;
-	this._request("https://steamcommunity.com/" + (typeof id === 'string' ? "groups/" + id : "gid/" + id.toString()) + "/memberslistxml/?xml=1", function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+	this.request("https://steamcommunity.com/" + (typeof id === 'string' ? "groups/" + id : "gid/" + id.toString()) + "/memberslistxml/?xml=1", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
@@ -65,9 +64,8 @@ CSteamGroup.prototype.getMembers = function(callback, members, link) {
 	link = link || "http://steamcommunity.com/gid/" + this.steamID.toString() + "/memberslistxml/?xml=1";
 	
 	var self = this;
-	this._community._request(link, function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+	this._community.request(link, function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
@@ -97,13 +95,13 @@ CSteamGroup.prototype.join = function(callback) {
 	};
 	
 	var self = this;
-	this._community._request.post("https://steamcommunity.com/gid/" + this.steamID.toString(), {"form": form}, function(err, response, body) {
+	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString(), {"form": form}, function(err, response, body) {
 		if(!callback) {
 			return;
 		}
 		
 		if(err || response.statusCode >= 400) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		
@@ -129,7 +127,7 @@ CSteamGroup.prototype.leave = function(callback) {
 		}
 		
 		if(err || response.statusCode >= 400) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		
@@ -149,13 +147,13 @@ CSteamGroup.prototype.postAnnouncement = function(headline, content, callback) {
 		"body": content
 	};
 	
-	this._community._request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/announcements", {"form": form}, function(err, response, body) {
+	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/announcements", {"form": form}, function(err, response, body) {
 		if(!callback) {
 			return;
 		}
 		
 		if(err || response.statusCode >= 400) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		
@@ -208,13 +206,13 @@ CSteamGroup.prototype.scheduleEvent = function(name, type, description, time, se
 	}
 	
 	var self = this;
-	this._community._request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/eventEdit", {"form": form}, function(err, response, body) {
+	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/eventEdit", {"form": form}, function(err, response, body) {
 		if(!callback) {
 			return;
 		}
 		
 		if(err || response.statusCode >= 400) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		
@@ -235,13 +233,13 @@ CSteamGroup.prototype.setPlayerOfTheWeek = function(steamID, callback) {
 	};
 	
 	var self = this;
-	this._community._request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/potwEdit", {"form": form}, function(err, response, body) {
+	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/potwEdit", {"form": form}, function(err, response, body) {
 		if(!callback) {
 			return;
 		}
 		
 		if(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		
@@ -254,7 +252,7 @@ CSteamGroup.prototype.setPlayerOfTheWeek = function(steamID, callback) {
 			if(results.response.results[0] == 'OK') {
 				callback(null, new SteamID(results.response.oldPOTW[0]), new SteamID(results.response.newPOTW[0]));
 			} else {
-				callback(results.response.results[0]);
+				callback(new Error(results.response.results[0]));
 			}
 		});
 	});
@@ -269,13 +267,13 @@ CSteamGroup.prototype.kick = function(steamID, callback) {
 	};
 	
 	var self = this;
-	this._community._request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/membersManage", {"form": form}, function(err, response, body) {
+	this._community.request.post("https://steamcommunity.com/gid/" + this.steamID.toString() + "/membersManage", {"form": form}, function(err, response, body) {
 		if(!callback) {
 			return;
 		}
 		
 		if(err || response.statusCode >= 400) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		

classes/CSteamUser.js

@@ -0,0 +1,226 @@
+var SteamCommunity = require('../index.js');
+var SteamID = require('steamid');
+var xml2js = require('xml2js');
+
+SteamCommunity.prototype.getSteamUser = function(id, callback) {
+	if(typeof id !== 'string' && !(typeof id === 'object' && id.__proto__ === SteamID.prototype)) {
+		throw new Error("id parameter should be a user URL string or a SteamID object");
+	}
+	
+	if(typeof id === 'object' && (id.universe != SteamID.Universe.PUBLIC || id.type != SteamID.Type.INDIVIDUAL)) {
+		throw new Error("SteamID must stand for an individual account in the public universe");
+	}
+	
+	var self = this;
+	this.request("http://steamcommunity.com/" + (typeof id === 'string' ? "id/" + id : "profiles/" + id.toString()) + "/?xml=1", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+		
+		xml2js.parseString(body, function(err, result) {
+			if(err || (!result.response && !result.profile)) {
+				callback(err || new Error("No valid response"));
+				return;
+			}
+			
+			if(result.response && result.response.error && result.response.error.length) {
+				callback(new Error(result.response.error[0]));
+				return;
+			}
+			
+			// Try and find custom URL from redirect
+			var customurl = null;
+			if(response.request.redirects && response.request.redirects.length) {
+				var match = response.request.redirects[0].redirectUri.match(/https?:\/\/steamcommunity\.com\/id\/([^/])+\/\?xml=1/);
+				if(match) {
+					customurl = match[1];
+				}
+			}
+			
+			callback(null, new CSteamUser(self, result.profile, customurl));
+		});
+	});
+};
+
+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;
+	
+	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;
+	} else {
+		this.memberSince = null;
+		this.location = null;
+		this.realName = null;
+		this.summary = null;
+	}
+	
+	// Maybe handle mostPlayedGames?
+	
+	this.groups = null;
+	this.primaryGroup = null;
+	
+	var self = this;
+	if(userData.groups && userData.groups[0] && userData.groups[0].group) {
+		this.groups = userData.groups[0].group.map(function(group) {
+			if(group['$'] && group['$'].isPrimary) {
+				self.primaryGroup = new SteamID(group.groupID64[0]);
+			}
+			
+			return new SteamID(group.groupID64[0]);
+		});
+	}
+}
+
+CSteamUser.getAvatarURL = function(hash, size, protocol) {
+	size = size || '';
+	protocol = protocol || 'http://';
+	
+	var url = protocol + "steamcdn-a.akamaihd.net/steamcommunity/public/images/avatars/" + hash.substring(0, 2) + "/" + hash;
+	if(size == 'full' || size == 'medium') {
+		return url + "_" + size + ".jpg";
+	} else {
+		return url + ".jpg";
+	}
+};
+
+CSteamUser.prototype.getAvatarURL = function(size, protocol) {
+	return CSteamUser.getAvatarURL(this.avatarHash, size, protocol);
+};
+
+CSteamUser.prototype.addFriend = function(callback) {
+	this._community.request.post('https://steamcommunity.com/actions/AddFriendAjax', {"form": {"accept_invite": 0, "sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		var json;
+		try {
+			json = JSON.parse(body);
+		} catch(e) {
+			callback(e);
+			return;
+		}
+		
+		if(json.success) {
+			callback(null);
+		} else {
+			callback(new Error("Unknown error"));
+		}
+	});
+};
+
+CSteamUser.prototype.acceptFriendRequest = function(callback) {
+	this._community.request.post('https://steamcommunity.com/actions/AddFriendAjax', {"form": {"accept_invite": 1, "sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		callback(null);
+	});
+};
+
+CSteamUser.prototype.removeFriend = function(callback) {
+	this._community.request.post('https://steamcommunity.com/actions/RemoveFriendAjax', {"form": {"sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		callback(null);
+	});
+};
+
+CSteamUser.prototype.blockCommunication = function(callback) {
+	this._community.request.post('https://steamcommunity.com/actions/BlockUserAjax', {"form": {"sessionID": this._community.getSessionID(), "steamid": this.steamID.toString()}}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		callback(null);
+	});
+};
+
+CSteamUser.prototype.unblockCommunication = function(callback) {
+	var form = {"action": "unignore"};
+	form['friends[' + this.steamID.toString() + ']'] = 1;
+	
+	this._community._myProfile('friends/blocked/', form, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(err || response.statusCode >= 400) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+		
+		callback(null);
+	});
+};
+
+CSteamUser.prototype.comment = function(message, callback) {
+	this._community.request.post('https://steamcommunity.com/comment/Profile/post/' + this.steamID.toString() + '/-1/', {"form": {
+		"comment": message,
+		"count": 6,
+		"sessionid": this._community.getSessionID()
+	}}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(err || response.statusCode != 200) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+		
+		var json;
+		try {
+			json = JSON.parse(body);
+		} catch(e) {
+			callback(e);
+			return;
+		}
+		
+		if(json.success) {
+			callback(null);
+		} else if(json.error) {
+			callback(new Error(json.error));
+		} else {
+			callback(new Error("Unknown error"));
+		}
+	});
+};

components/chat.js

@@ -0,0 +1,253 @@
+var SteamCommunity = require('../index.js');
+var SteamID = require('steamid');
+
+SteamCommunity.ChatState = {
+	"Offline": 0,
+	"LoggingOn": 1,
+	"LogOnFailed": 2,
+	"LoggedOn": 3
+};
+
+SteamCommunity.PersonaState = {
+	"Offline": 0,
+	"Online": 1,
+	"Busy": 2,
+	"Away": 3,
+	"Snooze": 4,
+	"LookingToTrade": 5,
+	"LookingToPlay": 6,
+	"Max": 7
+};
+
+SteamCommunity.PersonaStateFlag = {
+	"HasRichPresence": 1,
+	"InJoinableGame": 2,
+	
+	"OnlineUsingWeb": 256,
+	"OnlineUsingMobile": 512,
+	"OnlineUsingBigPicture": 1024
+};
+
+SteamCommunity.prototype.chatLogon = function(interval, uiMode) {
+	if(this.chatState == SteamCommunity.ChatState.LoggingOn || this.chatState == SteamCommunity.ChatState.LoggedOn) {
+		return;
+	}
+	
+	interval = interval || 500;
+	uiMode = uiMode || "web";
+	
+	this.emit('debug', 'Requesting chat WebAPI token');
+	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.');
+			self.chatState = SteamCommunity.ChatState.LogOnFailed;
+			setTimeout(self.chatLogon.bind(self), 5000);
+			return;
+		}
+		
+		self.request.post({
+			"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Logon/v1",
+			"form": {
+				"ui_mode": uiMode,
+				"access_token": match[0]
+			},
+			"json": true
+		}, function(err, response, body) {
+			if(err || response.statusCode != 200) {
+				self.emit('debug', 'Error logging into webchat: ' + (err ? err.message : "HTTP error " + response.statusCode));
+				self.chatState = SteamCommunity.ChatState.LogOnFailed;
+				setTimeout(self.chatLogon.bind(self), 5000);
+				return;
+			}
+			
+			if(body.error != 'OK') {
+				self.emit('debug', 'Error logging into webchat: ' + body.error);
+				self.chatState = SteamCommunity.ChatState.LogOnFailed;
+				setTimeout(self.chatLogon.bind(self), 5000);
+				return;
+			}
+			
+			self._chat = {
+				"umqid": body.umqid,
+				"message": body.message,
+				"accessToken": match[0],
+				"interval": interval
+			};
+			
+			self.chatFriends = {};
+			
+			self.chatState = SteamCommunity.ChatState.LoggedOn;
+			self.emit('chatLoggedOn');
+			self._chatPoll();
+		});
+	});
+};
+
+SteamCommunity.prototype.chatMessage = function(recipient, text, type, callback) {
+	if(this.chatState != SteamCommunity.ChatState.LoggedOn) {
+		throw new Error("Chat must be logged on before messages can be sent");
+	}
+	
+	if(typeof recipient === 'string') {
+		recipient = new SteamID(recipient);
+	}
+	
+	if(typeof type === 'function') {
+		callback = type;
+		type = 'saytext';
+	}
+	
+	type = type || 'saytext';
+	
+	this.request.post({
+		"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Message/v1",
+		"form": {
+			"access_token": this._chat.accessToken,
+			"steamid_dst": recipient.toString(),
+			"text": text,
+			"type": type,
+			"umqid": this._chat.umqid
+		},
+		"json": true
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		if(body.error != 'OK') {
+			callback(new Error(body.error));
+		} else {
+			callback(null);
+		}
+	});
+};
+
+SteamCommunity.prototype.chatLogoff = function() {
+	var self = this;
+	this.request.post({
+		"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Logoff/v1",
+		"form": {
+			"access_token": this._chat.accessToken,
+			"umqid": this._chat.umqid
+		}
+	}, function(err, response, body) {
+		if(err || response.statusCode != 200) {
+			self.emit('debug', 'Error logging off of chat: ' + (err ? err.message : "HTTP error " + response.statusCode));
+			setTimeout(self.chatLogoff.bind(self), 1000);
+		} else {
+			self.emit('chatLoggedOff');
+			clearTimeout(self._chat.timer);
+			delete self._chat;
+			delete self.chatFriends;
+			self.chatState = SteamCommunity.ChatState.Offline;
+		}
+	});
+};
+
+SteamCommunity.prototype._chatPoll = function() {
+	this.emit('debug', 'Doing chat poll');
+	
+	var self = this;
+	this.request.post({
+		"uri": "https://api.steampowered.com/ISteamWebUserPresenceOAuth/Poll/v1",
+		"form": {
+			"umqid": self._chat.umqid,
+			"message": self._chat.message,
+			"pollid": 1,
+			"sectimeout": 20,
+			"secidletime": 0,
+			"use_accountids": 1,
+			"access_token": self._chat.accessToken
+		},
+		"json": true
+	}, function(err, response, body) {
+		if(self.chatState == SteamCommunity.ChatState.Offline) {
+			return;
+		}
+		
+		self._chat.timer = setTimeout(self._chatPoll.bind(self), self._chat.interval);
+		
+		if(err || response.statusCode != 200) {
+			self.emit('debug', 'Error in chat poll: ' + (err ? err.message : "HTTP error " + response.statusCode));
+			return;
+		}
+		
+		if(body.error != 'OK') {
+			self.emit('debug', 'Error in chat poll: ' + body.error);
+			return;
+		}
+		
+		self._chat.message = body.messagelast;
+		
+		(body.messages || []).forEach(function(message) {
+			var sender = new SteamID();
+			sender.universe = SteamID.Universe.PUBLIC;
+			sender.type = SteamID.Type.INDIVIDUAL;
+			sender.instance = SteamID.Instance.DESKTOP;
+			sender.accountid = message.accountid_from;
+			
+			switch(message.type) {
+				case 'personastate':
+					self._chatUpdatePersona(sender);
+					break;
+				
+				case 'saytext':
+					self.emit('chatMessage', sender, message.text);
+					break;
+				
+				case 'typing':
+					self.emit('chatTyping', sender);
+					break;
+				
+				default:
+					self.emit('debug', 'Unhandled chat message type: ' + message.type);
+			}
+		});
+	});
+};
+
+SteamCommunity.prototype._chatUpdatePersona = function(steamID) {
+	this.emit('debug', 'Updating persona data for ' + steamID);
+	var self = this;
+	this.request({
+		"uri": "https://steamcommunity.com/chat/friendstate/" + steamID.accountid,
+		"json": true
+	}, function(err, response, body) {
+		if(err || response.statusCode != 200) {
+			self.emit('debug', 'Chat update persona error: ' + (err ? err.message : "HTTP error " + response.statusCode));
+			setTimeout(function() {
+				self._chatUpdatePersona(steamID);
+			}, 2000);
+			return;
+		}
+		
+		var persona = {
+			"steamID": steamID,
+			"personaName": body.m_strName,
+			"personaState": body.m_ePersonaState,
+			"personaStateFlags": body.m_nPersonaStateFlags || 0,
+			"avatarHash": body.m_strAvatarHash,
+			"inGame": !!body.m_bInGame,
+			"inGameAppID": body.m_nInGameAppID ? parseInt(body.m_nInGameAppID, 10) : null,
+			"inGameName": body.m_strInGameName || null
+		};
+
+		self.emit('chatPersonaState', steamID, persona);
+		self.chatFriends[steamID.getSteamID64()] = persona;
+	});
+};

components/profile.js

@@ -0,0 +1,198 @@
+var SteamCommunity = require('../index.js');
+var SteamID = require('steamid');
+var Cheerio = require('cheerio');
+
+SteamCommunity.PrivacyState = {
+	"Private": 1,
+	"FriendsOnly": 2,
+	"Public": 3
+};
+
+var CommentPrivacyState = {
+	"1": "commentselfonly",
+	"2": "commentfriendsonly",
+	"3": "commentanyone"
+};
+
+SteamCommunity.prototype.editProfile = function(settings, callback) {
+	var self = this;
+	this._myProfile("edit", null, function(err, response, body) {
+		if(err || response.statusCode != 200) {
+			if(callback) {
+				callback(err || new Error("HTTP error " + response.statusCode));
+			}
+			
+			return;
+		}
+		
+		var $ = Cheerio.load(body);
+		var form = $('#editForm');
+		if(!form) {
+			if(callback) {
+				callback(new Error("Malformed response"));
+			}
+			
+			return;
+		}
+		
+		var values = {};
+		form.serializeArray().forEach(function(item) {
+			values[item.name] = item.value;
+		});
+		
+		for(var i in settings) {
+			if(!settings.hasOwnProperty(i)) {
+				continue;
+			}
+			
+			switch(i) {
+				case 'name':
+					values.personaName = settings[i];
+					break;
+				
+				case 'realName':
+					values.real_name = settings[i];
+					break;
+				
+				case 'summary':
+					values.summary = settings[i];
+					break;
+				
+				case 'country':
+					values.country = settings[i];
+					break;
+				
+				case 'state':
+					values.state = settings[i];
+					break;
+				
+				case 'city':
+					values.city = settings[i];
+					break;
+				
+				case 'customURL':
+					values.customURL = settings[i];
+					break;
+				
+				case 'background':
+					// The assetid of our desired profile background
+					values.profile_background = settings[i];
+					break;
+				
+				case 'featuredBadge':
+					// Currently, game badges aren't supported
+					values.favorite_badge_badgeid = settings[i];
+					break;
+				
+				case 'primaryGroup':
+					if(typeof settings[i] === 'object' && settings[i].accountid) {
+						values.primary_group_steamid = settings[i].accountid;
+					} else {
+						values.primary_group_steamid = new SteamID(settings[i]).accountid;
+					}
+					
+					break;
+				
+				// TODO: profile showcases
+			}
+		}
+		
+		self._myProfile("edit", values, function(err, response, body) {
+			if(err || response.statusCode != 200) {
+				if(callback) {
+					callback(err || new Error("HTTP error " + response.statusCode));
+				}
+				
+				return;
+			}
+			
+			// Check for an error
+			var $ = Cheerio.load(body);
+			var error = $('#errorText .formRowFields');
+			if(error) {
+				error = error.text().trim();
+				if(error) {
+					if(callback) {
+						callback(new Error(error));
+					}
+					
+					return;
+				}
+			}
+			
+			if(callback) {
+				callback(null);
+			}
+		});
+	});
+};
+
+SteamCommunity.prototype.profileSettings = function(settings, callback) {
+	var self = this;
+	this._myProfile("edit/settings", null, function(err, response, body) {
+		if(err || response.statusCode != 200) {
+			if(callback) {
+				callback(err || new Error("HTTP error " + response.statusCode));
+			}
+			
+			return;
+		}
+		
+		var $ = Cheerio.load(body);
+		var form = $('#editForm');
+		if(!form) {
+			if(callback) {
+				callback(new Error("Malformed response"));
+			}
+			
+			return;
+		}
+		
+		var values = {};
+		form.serializeArray().forEach(function(item) {
+			values[item.name] = item.value;
+		});
+		
+		for(var i in settings) {
+			if(!settings.hasOwnProperty(i)) {
+				continue;
+			}
+			
+			switch(i) {
+				case 'profile':
+					values.privacySetting = settings[i];
+					break;
+				
+				case 'comments':
+					values.commentSetting = CommentPrivacyState[settings[i]];
+					break;
+				
+				case 'inventory':
+					values.inventoryPrivacySetting = settings[i];
+					break;
+				
+				case 'inventoryGifts':
+					values.inventoryGiftPrivacy = settings[i] ? 1 : 0;
+					break;
+				
+				case 'emailConfirmation':
+					values.tradeConfirmationSetting = settings[i] ? 1 : 0;
+					break;
+			}
+		}
+		
+		self._myProfile("edit/settings", values, function(err, response, body) {
+			if(err || response.statusCode != 200) {
+				if(callback) {
+					callback(err || new Error("HTTP error " + response.statusCode));
+				}
+				
+				return;
+			}
+			
+			if(callback) {
+				callback(null);
+			}
+		});
+	});
+};

index.js

@@ -3,22 +3,30 @@ var RSA = require('node-bignumber').Key;
 var hex2b64 = require('node-bignumber').hex2b64;
 var SteamID = require('steamid');
 
+require('util').inherits(SteamCommunity, require('events').EventEmitter);
+
 module.exports = SteamCommunity;
 
 SteamCommunity.SteamID = SteamID;
 
 function SteamCommunity() {
 	this._jar = Request.jar();
-	this._request = Request.defaults({"jar": this._jar});
+	this._captchaGid = -1;
+	this.request = Request.defaults({"jar": this._jar, "timeout": 50000});
+	this.chatState = SteamCommunity.ChatState.Offline;
+	
+	// English
+	this._jar.setCookie(Request.cookie('Steam_Language=english'), 'https://steamcommunity.com');
 }
 
 SteamCommunity.prototype.login = function(details, callback) {
-	if(details.steamID && details.sentry) {
-		this._jar.setCookie(Request.cookie('steamMachineAuth' + details.steamID.getSteamID64() + '=' + encodeURIComponent(details.sentry)), 'https://steamcommunity.com');
+	if(details.steamguard) {
+		var parts = details.steamguard.split('||');
+		this._jar.setCookie(Request.cookie('steamMachineAuth' + parts[0] + '=' + encodeURIComponent(parts[1])), 'https://steamcommunity.com');
 	}
 	
 	var self = this;
-	this._request.post("https://steamcommunity.com/login/getrsakey/", {"form": {"username": details.accountName}}, function(err, response, body) {
+	this.request.post("https://steamcommunity.com/login/getrsakey/", {"form": {"username": details.accountName}}, function(err, response, body) {
 		if(err) {
 			callback(err);
 			return;
@@ -36,40 +44,50 @@ SteamCommunity.prototype.login = function(details, callback) {
 		key.setPublic(json.publickey_mod, json.publickey_exp);
 		
 		var form = {
-			"captcha_text": "",
-			"captchagid": -1,
+			"captcha_text": details.captcha || "",
+			"captchagid": self._captchaGid,
 			"emailauth": details.authCode || "",
 			"emailsteamid": "",
 			"loginfriendlyname": "",
 			"password": hex2b64(key.encrypt(details.password)),
-			"remember_login": false,
+			"remember_login": "true",
 			"rsatimestamp": json.timestamp,
-			"twofactorcode": "",
+			"twofactorcode": details.twoFactorCode || "",
 			"username": details.accountName
 		};
 		
-		console.log(self._jar.getCookieString("https://steamcommunity.com"));
-		self._request.post("https://steamcommunity.com/login/dologin/", {"form": form}, function(err, response, body) {
-			if(err) {
-				callback(err);
+		self.request.post({
+			"uri": "https://steamcommunity.com/login/dologin/",
+			"json": true,
+			"form": form
+		}, function(err, response, body) {
+			if(self._checkHttpError(err, response, callback)) {
 				return;
 			}
 			
-			var json;
-			try {
-				json = JSON.parse(body);
-			} catch(e) {
-				callback(e);
-				return;
-			}
-			
-			if(!json.success) {
-				callback(json.message);
+			if(!body.success && body.emailauth_needed) {
+				// Steam Guard (email)
+				var error = new Error("SteamGuard");
+				error.emaildomain = body.emaildomain;
+				
+				callback(error);
+			} else if(!body.success && body.requires_twofactor) {
+				// Steam Guard (app)
+				callback(new Error("SteamGuardMobile"));
+			} else if(!body.success && body.captcha_needed) {
+				var error = new Error("CAPTCHA");
+				error.captchaurl = "https://steamcommunity.com/public/captcha.php?gid=" + body.captcha_gid;
+				
+				self._captchaGid = body.captcha_gid;
+				
+				callback(error);
+			} else if(!body.success) {
+				callback(new Error(body.message || "Unknown error"));
 			} else {
 				var sessionID = generateSessionID();
 				self._jar.setCookie(Request.cookie('sessionid=' + sessionID), 'http://steamcommunity.com');
 				
-				self.steamID = new SteamID(json.transfer_parameters.steamid);
+				self.steamID = new SteamID(body.transfer_parameters.steamid);
 				var cookies = self._jar.getCookieString("https://steamcommunity.com").split(';').map(function(cookie) {
 					return cookie.trim();
 				});
@@ -79,7 +97,7 @@ SteamCommunity.prototype.login = function(details, callback) {
 				for(var i = 0; i < cookies.length; i++) {
 					var parts = cookies[i].split('=');
 					if(parts[0] == 'steamMachineAuth' + self.steamID) {
-						steamguard = {"steamID": self.steamID, "sentry": decodeURIComponent(parts[1])};
+						steamguard = self.steamID.toString() + '||' + decodeURIComponent(parts[1]);
 						break;
 					}
 				}
@@ -120,10 +138,137 @@ function generateSessionID() {
 	return Math.floor(Math.random() * 1000000000);
 };
 
+SteamCommunity.prototype.getWebApiKey = function(domain, callback) {
+	var self = this;
+	this.request("https://steamcommunity.com/dev/apikey", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		if(body.match(/<h2>Access Denied<\/h2>/)) {
+			return callback("Access Denied");
+		}
+		
+		var match = body.match(/<p>Key: ([0-9A-F]+)<\/p>/);
+		if(match) {
+			// We already have an API key registered
+			callback(null, match[1]);
+		} else {
+			// We need to register a new API key
+			self.request.post('https://steamcommunity.com/dev/registerkey', {
+				"form": {
+					"domain": domain,
+					"agreeToTerms": "agreed",
+					"sessionid": self.getSessionID(),
+					"Submit": "Register"
+				}
+			}, function(err, response, body) {
+				if(err || response.statusCode >= 400) {
+					return callback(err.message || "HTTP error " + response.statusCode);
+				}
+				
+				self.getWebApiKey(domain, callback);
+			});
+		}
+	});
+};
+
+SteamCommunity.prototype.parentalUnlock = function(pin, callback) {
+	this.request.post("https://steamcommunity.com/parental/ajaxunlock", {
+		"json": true,
+		"form": {
+			"pin": pin
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		if(!body || typeof body.success !== 'boolean') {
+			return callback("Invalid response");
+		}
+		
+		if(!body.success) {
+			return callback("Incorrect PIN");
+		}
+		
+		callback();
+	}.bind(this));
+};
+
+SteamCommunity.prototype.getNotifications = function(callback) {
+	this.request.get("https://steamcommunity.com/actions/RefreshNotificationArea", function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		var notifications = {
+			"comments": 0,
+			"items": 0,
+			"invites": 0,
+			"gifts": 0,
+			"chat": 0,
+			"trades": 0
+		};
+		
+		var items = {
+			"comments": /(\d+) new comments?/,
+			"items": /(\d+) new items? in your inventory/,
+			"invites": /(\d+) new invites?/,
+			"gifts": /(\d+) new gifts?/,
+			"chat": /(\d+) unread chat messages?/,
+			"trades": /(\d+) new trade notifications?/
+		};
+		
+		var match;
+		for(var i in items) {
+			if(match = body.match(items[i])) {
+				notifications[i] = parseInt(match[1], 10);
+			}
+		}
+		
+		callback(null, notifications);
+	});
+};
+
+SteamCommunity.prototype.resetItemNotifications = function(callback) {
+	this.request.get("https://steamcommunity.com/my/inventory", function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		callback(null);
+	});
+};
+
+SteamCommunity.prototype.loggedIn = function(callback) {
+	this.request("https://steamcommunity.com/my", {"followRedirect": false}, function(err, response, body) {
+		if(err || (response.statusCode != 302 && response.statusCode != 403)) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+		
+		if(response.statusCode == 403) {
+			callback(null, true, true);
+			return;
+		}
+		
+		callback(null, !!response.headers.location.match(/steamcommunity\.com(\/(id|profiles)\/[^\/]+)\/?/), false);
+	});
+};
+
 SteamCommunity.prototype._checkCommunityError = function(html, callback) {
 	if(html.match(/<h1>Sorry!<\/h1>/)) {
 		var match = html.match(/<h3>(.+)<\/h3>/);
-		callback(match ? match[1] : "Unknown error occurred");
+		callback(new Error(match ? match[1] : "Unknown error occurred"));
 		return true;
 	}
 	
@@ -132,7 +277,7 @@ SteamCommunity.prototype._checkCommunityError = function(html, callback) {
 
 SteamCommunity.prototype._myProfile = function(endpoint, form, callback) {
 	var self = this;
-	this._request("https://steamcommunity.com/my", {"followRedirect": false}, function(err, response, body) {
+	this.request("https://steamcommunity.com/my", {"followRedirect": false}, function(err, response, body) {
 		if(err || response.statusCode != 302) {
 			callback(err || "HTTP error " + response.statusCode);
 			return;
@@ -144,8 +289,29 @@ SteamCommunity.prototype._myProfile = function(endpoint, form, callback) {
 			return;
 		}
 		
-		(form ? self._request.post : self._request)("https://steamcommunity.com" + match[1] + "/" + endpoint, form ? {"form": form} : {}, callback);
+		(form ? self.request.post : self.request)("https://steamcommunity.com" + match[1] + "/" + endpoint, form ? {"form": form} : {}, callback);
 	});
 };
 
+SteamCommunity.prototype._checkHttpError = function(err, response, callback) {
+	if(err) {
+		callback(err);
+		return true;
+	}
+	
+	if(response.statusCode != 200) {
+		var error = new Error("HTTP error " + response.statusCode);
+		error.code = response.statusCode;
+		callback(error);
+		return true;
+	}
+	
+	return false;
+};
+
+require('./classes/CMarketItem.js');
+require('./classes/CMarketSearchResult.js');
 require('./classes/CSteamGroup.js');
+require('./classes/CSteamUser.js');
+require('./components/chat.js');
+require('./components/profile.js');

package.json

@@ -1,7 +1,7 @@
 {
 	"name": "steamcommunity",
-	"version": "1.0.0",
-	"description": "Facilitates logins to the Steam Communtiy website",
+	"version": "3.2.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",
 	"bugs": {
@@ -10,12 +10,13 @@
 	"license": "MIT",
 	"repository": {
 		"type": "git",
-		"url": "https://github.com/Doctor_McKay/node-steamcommunity.git"
+		"url": "https://github.com/DoctorMcKay/node-steamcommunity.git"
 	},
 	"dependencies": {
-		"request":			"2.51.x",
-		"node-bignumber":	"1.2.x",
-		"steamid":			"0.1.x",
-		"xml2js":			"0.4.x"
+		"request":			"^2.58.0",
+		"node-bignumber":	"^1.2.1",
+		"steamid":			"^0.3.0",
+		"xml2js":			"^0.4.9",
+		"cheerio":			"^0.19.0"
 	}
 }