3.5.0

Add getMarketApps component

.gitignore

@@ -1,2 +1,3 @@
 node_modules/*
 test.js
+.idea/

classes/CMarketItem.js

@@ -4,14 +4,13 @@ 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(err || response.statusCode != 200) {
-			callback(err ? err.message : "HTTP error " + response.statusCode);
+		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('There are no listings for this item.');
+			callback(new Error("There are no listings for this item."));
 			return;
 		}
 		
@@ -93,17 +92,13 @@ CMarketItem.prototype.updatePrice = function(callback) {
 		"uri": "https://steamcommunity.com/market/itemordershistogram?country=US&language=english&currency=1&item_nameid=" + this.commodityID,
 		"json": true,
 	}, function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			if(callback) {
-				callback(err ? err.message : "HTTP error " + response.statusCode);
-			}
-			
+		if(self._community._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
 		if(body.success != 1) {
 			if(callback) {
-				callback("Error " + body.success);
+				callback(new Error("Error " + body.success));
 			}
 			
 			return;
@@ -125,7 +120,7 @@ CMarketItem.prototype.updatePrice = function(callback) {
 		
 		// TODO: The tables?
 		if(callback) {
-			callback();
+			callback(null);
 		}
 	});
 };

classes/CMarketSearchResult.js

@@ -25,10 +25,13 @@ SteamCommunity.prototype.marketSearch = function(options, callback) {
 	
 	qs.start = 0;
 	qs.count = 100;
-	performSearch(this.request, qs, [], callback);
+	qs.sort_column = 'price';
+	qs.sort_dir = 'asc';
+	performSearch.call(this, this.request, qs, [], callback);
 };
 
 function performSearch(request, qs, results, callback) {
+	var self = this;
 	request({
 		"uri": "https://steamcommunity.com/market/search/render/",
 		"qs": qs,
@@ -37,24 +40,23 @@ function performSearch(request, qs, results, callback) {
 		},
 		"json": true
 	}, function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			callback(err ? err.message : "HTTP error " + response.statusCode);
+		if(self._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
 		if(!body.success) {
-			callback("Success is not true");
+			callback(new Error("Success is not true"));
 			return;
 		}
 		
 		if(!body.results_html) {
-			callback("No results_html in response");
+			callback(new Error("No results_html in response"));
 			return;
 		}
 		
 		var $ = Cheerio.load(body.results_html);
 		if($('.market_listing_table_message').length > 0) {
-			callback($('.market_listing_table_message').text());
+			callback(new Error($('.market_listing_table_message').text()));
 			return;
 		}
 		

classes/CSteamGroup.js

@@ -13,8 +13,7 @@ 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);
+		if(self._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
@@ -60,229 +59,39 @@ CSteamGroup.prototype.getAvatarURL = function(size, protocol) {
 	}
 };
 
-CSteamGroup.prototype.getMembers = function(callback, members, link) {
-	members = members || [];
-	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);
-			return;
-		}
-		
-		xml2js.parseString(body, function(err, result) {
-			if(err) {
-				callback(err);
-				return;
-			}
-			
-			members = members.concat(result.memberList.members[0].steamID64.map(function(steamID) {
-				return new SteamID(steamID);
-			}));
-			
-			if(result.memberList.nextPageLink) {
-				self.getMembers(callback, members, result.memberList.nextPageLink[0]);
-			} else {
-				callback(null, members);
-			}
-		});
-	});
+CSteamGroup.prototype.getMembers = function(addresses, callback) {
+	if(typeof addresses === 'function') {
+		callback = addresses;
+		addresses = null;
+	}
+
+	this._community.getGroupMembers(this.steamID, callback, null, null, addresses, 0);
 };
 
 CSteamGroup.prototype.join = function(callback) {
-	var form = {
-		"action": "join",
-		"sessionID": this._community.getSessionID()
-	};
-	
-	var self = this;
-	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);
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.joinGroup(this.steamID, callback);
 };
 
 CSteamGroup.prototype.leave = function(callback) {
-	var form = {
-		"sessionID": this._community.getSessionID(),
-		"action": "leaveGroup",
-		"groupId": this.steamID.toString()
-	};
-	
-	var self = this;
-	this._community._myProfile("home_process", form, function(err, response, body) {
-		if(!callback) {
-			return;
-		}
-		
-		if(err || response.statusCode >= 400) {
-			callback(err || "HTTP error " + response.statusCode);
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.leaveGroup(this.steamID, callback);
 };
 
 CSteamGroup.prototype.postAnnouncement = function(headline, content, callback) {
-	var form = {
-		"sessionID": this._community.getSessionID(),
-		"action": "post",
-		"headline": headline,
-		"body": content
-	};
-	
-	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);
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.postGroupAnnouncement(this.steamID, headline, content, callback);
 };
 
 CSteamGroup.prototype.scheduleEvent = function(name, type, description, time, server, callback) {
-	// Event types: ChatEvent - Chat, OtherEvent - A lil somethin somethin, PartyEvent - Party!, MeetingEvent - Important meeting, SpecialCauseEvent - Special cause (charity ball?), MusicAndArtsEvent - Music or Art type thing, SportsEvent - Sporting endeavor, TripEvent - Out of town excursion
-	// Passing a number for type will make it a game event for that appid
-	
-	if(typeof server === 'function') {
-		callback = server;
-		server = {"ip": "", "password": ""};
-	} else if(typeof server === 'string') {
-		server = {"ip": server, "password": ""};
-	} else {
-		server = {"ip": "", "password": ""};
-	}
-	
-	var form = {
-		"sessionid": this._community.getSessionID(),
-		"action": "newEvent",
-		"tzOffset": new Date().getTimezoneOffset() * -60,
-		"name": name,
-		"type": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? "GameEvent" : type),
-		"appID": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? type : ''),
-		"serverIP": server.ip,
-		"serverPassword": server.password,
-		"notes": description,
-		"eventQuickTime": "now"
-	};
-	
-	if(time === null) {
-		form.startDate = 'MM/DD/YY';
-		form.startHour = '12';
-		form.startMinute = '00';
-		form.startAMPM = 'PM';
-		form.timeChoice = 'quick';
-	} else {
-		form.startDate = (time.getMonth() + 1 < 10 ? '0' : '') + (time.getMonth() + 1) + '/' + (time.getDate() < 10 ? '0' : '') + time.getDate() + '/' + time.getFullYear().toString().substring(2);
-		form.startHour = (time.getHours() === 0 ? '12' : (time.getHours() > 12 ? time.getHours() - 12 : time.getHours()));
-		form.startMinute = (time.getMinutes() < 10 ? '0' : '') + time.getMinutes();
-		form.startAMPM = (time.getHours() <= 12 ? 'AM' : 'PM');
-		form.timeChoice = 'specific';
-	}
-	
-	var self = this;
-	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);
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.scheduleGroupEvent(this.steamID, name, type, description, time, server, callback);
 };
 
 CSteamGroup.prototype.setPlayerOfTheWeek = function(steamID, callback) {
-	var form = {
-		"xml": 1,
-		"action": "potw",
-		"memberId": steamID.getSteam3RenderedID(),
-		"sessionid": this._community.getSessionID()
-	};
-	
-	var self = this;
-	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);
-			return;
-		}
-		
-		xml2js.parseString(body, function(err, results) {
-			if(err) {
-				callback(err);
-				return;
-			}
-			
-			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]);
-			}
-		});
-	});
+	this._community.setGroupPlayerOfTheWeek(this.steamID, steamID, callback);
 };
 
 CSteamGroup.prototype.kick = function(steamID, callback) {
-	var form = {
-		"sessionID": this._community.getSessionID(),
-		"action": "kick",
-		"memberId": steamID.toString(),
-		"queryString": ""
-	};
-	
-	var self = this;
-	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);
-			return;
-		}
-		
-		if(self._community._checkCommunityError(body, callback)) {
-			return;
-		}
-		
-		callback(null);
-	});
+	this._community.kickGroupMember(this.steamID, steamID, callback);
+};
+
+CSteamGroup.prototype.getHistory = function(page, callback) {
+	this._community.getGroupHistory(this.steamID, page, callback);
 };

classes/CSteamUser.js

@@ -13,8 +13,7 @@ SteamCommunity.prototype.getSteamUser = function(id, callback) {
 	
 	var self = this;
 	this.request("http://steamcommunity.com/" + (typeof id === 'string' ? "id/" + id : "profiles/" + id.toString()) + "/?xml=1", function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+		if(self._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
@@ -24,12 +23,12 @@ SteamCommunity.prototype.getSteamUser = function(id, callback) {
 		
 		xml2js.parseString(body, function(err, result) {
 			if(err || (!result.response && !result.profile)) {
-				callback(err || "No valid response");
+				callback(err || new Error("No valid response"));
 				return;
 			}
 			
 			if(result.response && result.response.error && result.response.error.length) {
-				callback(result.response.error[0]);
+				callback(new Error(result.response.error[0]));
 				return;
 			}
 			
@@ -108,13 +107,13 @@ CSteamUser.prototype.getAvatarURL = function(size, protocol) {
 };
 
 CSteamUser.prototype.addFriend = function(callback) {
+	var self = this;
 	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(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+		if(self._community._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
@@ -127,55 +126,55 @@ CSteamUser.prototype.addFriend = function(callback) {
 		}
 		
 		if(json.success) {
-			callback();
+			callback(null);
 		} else {
-			callback("Unknown error");
+			callback(new Error("Unknown error"));
 		}
 	});
 };
 
 CSteamUser.prototype.acceptFriendRequest = function(callback) {
+	var self = this;
 	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(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+		if(self._community._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
-		callback();
+		callback(null);
 	});
 };
 
 CSteamUser.prototype.removeFriend = function(callback) {
+	var self = this;
 	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(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+		if(self._community._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
-		callback();
+		callback(null);
 	});
 };
 
 CSteamUser.prototype.blockCommunication = function(callback) {
+	var self = this;
 	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(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+		if(self._community._checkHttpError(err, response, callback)) {
 			return;
 		}
 		
-		callback();
+		callback(null);
 	});
 };
 
@@ -189,11 +188,11 @@ CSteamUser.prototype.unblockCommunication = function(callback) {
 		}
 		
 		if(err || response.statusCode >= 400) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		
-		callback();
+		callback(null);
 	});
 };
 
@@ -208,7 +207,7 @@ CSteamUser.prototype.comment = function(message, callback) {
 		}
 		
 		if(err || response.statusCode != 200) {
-			callback(err || "HTTP error " + response.statusCode);
+			callback(err || new Error("HTTP error " + response.statusCode));
 			return;
 		}
 		
@@ -221,11 +220,11 @@ CSteamUser.prototype.comment = function(message, callback) {
 		}
 		
 		if(json.success) {
-			callback();
+			callback(null);
 		} else if(json.error) {
-			callback(json.error);
+			callback(new Error(json.error));
 		} else {
-			callback("Unknown error");
+			callback(new Error("Unknown error"));
 		}
 	});
 };

components/chat.js

@@ -125,12 +125,14 @@ SteamCommunity.prototype.chatMessage = function(recipient, text, type, callback)
 			return;
 		}
 		
-		if(err || response.statusCode != 200) {
-			callback(err ? err.message : "HTTP error " + response.statusCode);
-		} else if(body.error != 'OK') {
-			callback(body.error);
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		
+		if(body.error != 'OK') {
+			callback(new Error(body.error));
 		} else {
-			callback();
+			callback(null);
 		}
 	});
 };

components/groups.js

@@ -0,0 +1,386 @@
+var SteamCommunity = require('../index.js');
+var SteamID = require('steamid');
+var xml2js = require('xml2js');
+var Cheerio = require('cheerio');
+
+SteamCommunity.prototype.getGroupMembers = function(gid, callback, members, link, addresses, addressIdx) {
+	members = members || [];
+
+	if (!link) {
+		if (typeof gid !== 'string') {
+			// It's a SteamID object
+			link = "https://steamcommunity.com/gid/" + gid.toString() + "/memberslistxml/?xml=1";
+		} else {
+			try {
+				var sid = new SteamID(gid);
+				if (sid.type == SteamID.Type.CLAN && sid.isValid()) {
+					link = "https://steamcommunity.com/gid/" + sid.getSteamID64() + "/memberslistxml/?xml=1";
+				} else {
+					throw new Error("Doesn't particularly matter what this message is");
+				}
+			} catch (e) {
+				link = "https://steamcommunity.com/groups/" + gid + "/memberslistxml/?xml=1";
+			}
+		}
+	}
+
+	addressIdx = addressIdx || 0;
+
+	var options = {};
+	options.uri = link;
+
+	if(addresses) {
+		if(addressIdx >= addresses.length) {
+			addressIdx = 0;
+		}
+
+		options.localAddress = addresses[addressIdx];
+	}
+
+	var self = this;
+	this.request(options, function(err, response, body) {
+		if (self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		xml2js.parseString(body, function(err, result) {
+			if (err) {
+				callback(err);
+				return;
+			}
+
+			members = members.concat(result.memberList.members[0].steamID64.map(function(steamID) {
+				return new SteamID(steamID);
+			}));
+
+			if (result.memberList.nextPageLink) {
+				addressIdx++;
+				self.getGroupMembers(gid, callback, members, result.memberList.nextPageLink, addresses, addressIdx);
+			} else {
+				callback(null, members);
+			}
+		});
+	});
+};
+
+SteamCommunity.prototype.getGroupMembersEx = function(gid, addresses, callback) {
+	this.getGroupMembers(gid, callback, null, null, addresses, 0);
+};
+
+SteamCommunity.prototype.joinGroup = function(gid, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+	this.request.post({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64(),
+		"form": {
+			"action": "join",
+			"sessionID": this.getSessionID()
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode >= 400) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	});
+};
+
+SteamCommunity.prototype.leaveGroup = function(gid, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+	this._myProfile("home_process", {
+		"sessionID": this.getSessionID(),
+		"action": "leaveGroup",
+		"groupId": gid.getSteamID64()
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode >= 400) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	});
+};
+
+SteamCommunity.prototype.postGroupAnnouncement = function(gid, headline, content, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+	this.request.post({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/announcements",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"action": "post",
+			"headline": headline,
+			"body": content
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode >= 400) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	})
+};
+
+SteamCommunity.prototype.scheduleGroupEvent = function(gid, name, type, description, time, server, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	// Event types: ChatEvent - Chat, OtherEvent - A lil somethin somethin, PartyEvent - Party!, MeetingEvent - Important meeting, SpecialCauseEvent - Special cause (charity ball?), MusicAndArtsEvent - Music or Art type thing, SportsEvent - Sporting endeavor, TripEvent - Out of town excursion
+	// Passing a number for type will make it a game event for that appid
+
+	if(typeof server === 'function') {
+		callback = server;
+		server = {"ip": "", "password": ""};
+	} else if(typeof server === 'string') {
+		server = {"ip": server, "password": ""};
+	} else {
+		server = {"ip": "", "password": ""};
+	}
+
+	var form = {
+		"sessionid": this.getSessionID(),
+		"action": "newEvent",
+		"tzOffset": new Date().getTimezoneOffset() * -60,
+		"name": name,
+		"type": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? "GameEvent" : type),
+		"appID": (typeof type === 'number' || !isNaN(parseInt(type, 10)) ? type : ''),
+		"serverIP": server.ip,
+		"serverPassword": server.password,
+		"notes": description,
+		"eventQuickTime": "now"
+	};
+
+	if(time === null) {
+		form.startDate = 'MM/DD/YY';
+		form.startHour = '12';
+		form.startMinute = '00';
+		form.startAMPM = 'PM';
+		form.timeChoice = 'quick';
+	} else {
+		form.startDate = (time.getMonth() + 1 < 10 ? '0' : '') + (time.getMonth() + 1) + '/' + (time.getDate() < 10 ? '0' : '') + time.getDate() + '/' + time.getFullYear().toString().substring(2);
+		form.startHour = (time.getHours() === 0 ? '12' : (time.getHours() > 12 ? time.getHours() - 12 : time.getHours()));
+		form.startMinute = (time.getMinutes() < 10 ? '0' : '') + time.getMinutes();
+		form.startAMPM = (time.getHours() <= 12 ? 'AM' : 'PM');
+		form.timeChoice = 'specific';
+	}
+
+	var self = this;
+	this.request.post({
+		"uri": "https://steamcommunity.com/gid/" + this.steamID.toString() + "/eventEdit",
+		"form": form
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode >= 400) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	});
+};
+
+SteamCommunity.prototype.setGroupPlayerOfTheWeek = function(gid, steamID, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof steamID === 'string') {
+		steamID = new SteamID(steamID);
+	}
+
+	var self = this;
+	this.request.post({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/potwEdit",
+		"form": {
+			"xml": 1,
+			"action": "potw",
+			"memberId": steamID.getSteam3RenderedID(),
+			"sessionid": this.getSessionID()
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode != 200) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		xml2js.parseString(body, function(err, results) {
+			if(err) {
+				callback(err);
+				return;
+			}
+
+			if(results.response.results[0] == 'OK') {
+				callback(null, new SteamID(results.response.oldPOTW[0]), new SteamID(results.response.newPOTW[0]));
+			} else {
+				callback(new Error(results.response.results[0]));
+			}
+		});
+	});
+};
+
+SteamCommunity.prototype.kickGroupMember = function(gid, steamID, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof steamID === 'string') {
+		steamID = new SteamID(steamID);
+	}
+
+	var self = this;
+	this.request.post({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/membersManage",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"action": "kick",
+			"memberId": steamID.getSteamID64(),
+			"queryString": ""
+		}
+	}, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(err || response.statusCode >= 400) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	});
+};
+
+SteamCommunity.prototype.getGroupHistory = function(gid, page, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof page === 'function') {
+		callback = page;
+		page = 1;
+	}
+
+	var self = this;
+	this.request("https://steamcommunity.com/gid/" + gid.getSteamID64() + "/history?p=" + page, function(err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		var $ = Cheerio.load(body);
+		var output = {};
+
+		var paging = $('.group_paging p').text();
+		var match = paging.match(/(\d+) - (\d+) of (\d+)/);
+
+		if(match) {
+			output.first = parseInt(match[1], 10);
+			output.last = parseInt(match[2], 10);
+			output.total = parseInt(match[3], 10);
+		}
+
+		output.items = [];
+		var currentYear = (new Date()).getFullYear();
+		var lastDate = Date.now();
+
+		Array.prototype.forEach.call($('.historyItem, .historyItemb'), function(item) {
+			var data = {};
+
+			var $item = $(item);
+			data.type = $item.find('.historyShort').text().replace(/ /g, '');
+
+			var users = $item.find('.whiteLink[data-miniprofile]');
+			var sid;
+			if(users[0]) {
+				sid = new SteamID();
+				sid.universe = SteamID.Universe.PUBLIC;
+				sid.type = SteamID.Type.INDIVIDUAL;
+				sid.instance = SteamID.Instance.DESKTOP;
+				sid.accountid = $(users[0]).data('miniprofile');
+				data.user = sid;
+			}
+
+			if(users[1]) {
+				sid = new SteamID();
+				sid.universe = SteamID.Universe.PUBLIC;
+				sid.type = SteamID.Type.INDIVIDUAL;
+				sid.instance = SteamID.Instance.DESKTOP;
+				sid.accountid = $(users[0]).data('miniprofile');
+				data.actor = sid;
+			}
+
+			// Figure out the date. Of course there's no year, because Valve
+			var dateParts = $item.find('.historyDate').text().split('@');
+			var date = dateParts[0].trim().replace(/(st|nd|th)$/, '').trim() + ', ' + currentYear;
+			var time = dateParts[1].trim().replace(/(am|pm)/, ' $1');
+
+			date = new Date(date + ' ' + time);
+
+			// If this date is in the future, or it's later than the previous one, decrement the year
+			if(date.getTime() > lastDate) {
+				date.setFullYear(date.getFullYear() - 1);
+			}
+
+			data.date = date;
+
+			output.items.push(data);
+		});
+
+		callback(null, output);
+	});
+};

components/market.js

@@ -0,0 +1,25 @@
+var SteamCommunity = require('../index.js');
+var Cheerio = require('cheerio');
+
+SteamCommunity.prototype.getMarketApps = function(callback) {
+	var self = this;
+	this.request('https://steamcommunity.com/market/', function (err, response, body) {
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+		var $ = Cheerio.load(body);
+		if ($('.market_search_game_button_group')) {
+			apps = {};
+			$('.market_search_game_button_group > a').each(function (i, element) {
+				var e = Cheerio.load(element);
+				var name = e('.game_button_game_name').text().trim();
+				var url = element.attribs.href;
+				var appid = url.substr(url.indexOf('=') + 1);
+				apps[appid] = name;
+			});
+			callback(null, apps);
+		} else {
+			callback(new Error("Malformed response"));
+		}
+	});
+}

components/profile.js

@@ -0,0 +1,213 @@
+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.setupProfile = function(callback) {
+	var self = this;
+	this._myProfile("edit?welcomed=1", null, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+		
+		if(err || response.statusCode != 200) {
+			callback(err || new Error("HTTP error " + response.statusCode));
+		} else {
+			callback(null);
+		}
+	});
+};
+
+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

@@ -9,10 +9,17 @@ module.exports = SteamCommunity;
 
 SteamCommunity.SteamID = SteamID;
 
-function SteamCommunity() {
+function SteamCommunity(localAddress) {
 	this._jar = Request.jar();
-	this.request = Request.defaults({"jar": this._jar});
+	this._captchaGid = -1;
 	this.chatState = SteamCommunity.ChatState.Offline;
+
+	var defaults = {"jar": this._jar, "timeout": 50000};
+	if(localAddress) {
+		defaults.localAddress = localAddress;
+	}
+
+	this.request = Request.defaults(defaults);
 	
 	// English
 	this._jar.setCookie(Request.cookie('Steam_Language=english'), 'https://steamcommunity.com');
@@ -43,15 +50,15 @@ 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": "true",
 			"rsatimestamp": json.timestamp,
-			"twofactorcode": "",
+			"twofactorcode": details.twoFactorCode || "",
 			"username": details.accountName
 		};
 		
@@ -60,15 +67,28 @@ SteamCommunity.prototype.login = function(details, callback) {
 			"json": true,
 			"form": form
 		}, function(err, response, body) {
-			if(err) {
-				callback(err);
+			if(self._checkHttpError(err, response, callback)) {
 				return;
 			}
 			
 			if(!body.success && body.emailauth_needed) {
-				callback("Please provide the authorization code sent to your address at " + body.emaildomain);
+				// 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(body.message || "Unknown error");
+				callback(new Error(body.message || "Unknown error"));
 			} else {
 				var sessionID = generateSessionID();
 				self._jar.setCookie(Request.cookie('sessionid=' + sessionID), 'http://steamcommunity.com');
@@ -127,8 +147,8 @@ function generateSessionID() {
 SteamCommunity.prototype.getWebApiKey = function(domain, callback) {
 	var self = this;
 	this.request("https://steamcommunity.com/dev/apikey", function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			return callback(err.message || "HTTP error " + response.statusCode);
+		if(self._checkHttpError(err, response, callback)) {
+			return;
 		}
 		
 		if(body.match(/<h2>Access Denied<\/h2>/)) {
@@ -170,8 +190,8 @@ SteamCommunity.prototype.parentalUnlock = function(pin, callback) {
 			return;
 		}
 		
-		if(err || response.statusCode != 200) {
-			return callback(err.message || "HTTP error " + response.statusCode);
+		if(self._checkHttpError(err, response, callback)) {
+			return;
 		}
 		
 		if(!body || typeof body.success !== 'boolean') {
@@ -188,8 +208,8 @@ SteamCommunity.prototype.parentalUnlock = function(pin, callback) {
 
 SteamCommunity.prototype.getNotifications = function(callback) {
 	this.request.get("https://steamcommunity.com/actions/RefreshNotificationArea", function(err, response, body) {
-		if(err || response.statusCode != 200) {
-			return callback(err.message || "HTTP error " + response.statusCode);
+		if(self._checkHttpError(err, response, callback)) {
+			return;
 		}
 		
 		var notifications = {
@@ -227,18 +247,34 @@ SteamCommunity.prototype.resetItemNotifications = function(callback) {
 			return;
 		}
 		
-		if(err || response.statusCode != 200) {
-			callback(err.message || "HTTP error " + response.statusCode);
-		} else {
-			callback();
+		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;
 	}
 	
@@ -263,8 +299,27 @@ SteamCommunity.prototype._myProfile = function(endpoint, 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('./components/chat.js');
+require('./components/profile.js');
+require('./components/market.js');
+require('./components/groups.js');
 require('./classes/CMarketItem.js');
 require('./classes/CMarketSearchResult.js');
 require('./classes/CSteamGroup.js');
 require('./classes/CSteamUser.js');
-require('./components/chat.js');

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "steamcommunity",
-	"version": "2.5.1",
+	"version": "3.5.0",
 	"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",