3.18.4

Adding ability to edit an annoucement.

classes/CSteamGroup.js

@@ -64,7 +64,7 @@ CSteamGroup.prototype.getMembers = function(addresses, callback) {
 		callback = addresses;
 		addresses = null;
 	}
-
+	
 	this._community.getGroupMembers(this.steamID, callback, null, null, addresses, 0);
 };
 
@@ -76,10 +76,22 @@ CSteamGroup.prototype.leave = function(callback) {
 	this._community.leaveGroup(this.steamID, callback);
 };
 
+CSteamGroup.prototype.getAllAnnouncements = function(time, callback) {
+	this._community.getAllGroupAnnouncements(this.steamID, time, callback);
+};
+
 CSteamGroup.prototype.postAnnouncement = function(headline, content, callback) {
 	this._community.postGroupAnnouncement(this.steamID, headline, content, callback);
 };
 
+CSteamGroup.prototype.editAnnouncement = function(annoucementID, headline, content, callback) {
+	this._community.editGroupAnnouncement(this.steamID, annoucementID, headline, content, callback)
+};
+
+CSteamGroup.prototype.deleteAnnouncement = function(annoucementID, callback) {
+	this._community.deleteGroupAnnouncement(this.steamID, annoucementID, callback)
+};
+
 CSteamGroup.prototype.scheduleEvent = function(name, type, description, time, server, callback) {
 	this._community.scheduleGroupEvent(this.steamID, name, type, description, time, server, callback);
 };

components/confirmations.js

@@ -141,7 +141,7 @@ SteamCommunity.prototype.respondToConfirmation = function(confID, confKey, time,
 
 function request(community, url, key, time, tag, params, json, callback) {
 	params = params || {};
-	params.p = "android:" + require('crypto').randomBytes(16).toString('hex');
+	params.p = SteamTotp.getDeviceID(community.steamID);
 	params.a = community.steamID.getSteamID64();
 	params.k = key;
 	params.t = time;
@@ -239,6 +239,7 @@ SteamCommunity.prototype.checkConfirmations = function() {
 
 		self.getConfirmations(key.time, key.key, function(err, confirmations) {
 			if(err) {
+				this.emit('debug', "Can't check confirmations: " + err.message);
 				resetTimer();
 				return;
 			}
@@ -287,9 +288,14 @@ SteamCommunity.prototype.checkConfirmations = function() {
 		// Delay them by 1 second per new confirmation that we see, so that keys won't be the same.
 		setTimeout(function() {
 			if(self._identitySecret) {
-				self.emit('debug', 'Accepting confirmation ' + conf.id);
+				self.emit('debug', 'Accepting confirmation #' + conf.id);
 				var time = Math.floor(Date.now() / 1000);
-				conf.respond(time, SteamTotp.getConfirmationKey(self._identitySecret, time, "allow"), true, function() {
+				conf.respond(time, SteamTotp.getConfirmationKey(self._identitySecret, time, "allow"), true, function(err) {
+					if (err) {
+						self.emit('debug', "Can't accept confirmation #" + conf.id + ": " + err.message);
+					}
+
+					// We'll just retry next time we poll
 					delete self._knownConfirmations[conf.id];
 				});
 			} else {

components/groups.js

@@ -125,6 +125,56 @@ SteamCommunity.prototype.leaveGroup = function(gid, callback) {
 	});
 };
 
+SteamCommunity.prototype.getAllGroupAnnouncements = function(gid, time, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	if(typeof time === 'function') {
+		callback = time;
+		time = new Date(0); // The beginnig of time...
+	}
+
+	var self = this;
+	this.request({
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/rss/" 
+	}, function(err, response, body) {
+
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		xml2js.parseString(body, function(err, results) {
+			if(err) {
+				return callback(err);
+			}
+
+			if(!results.rss.channel[0].item) {
+				return callback(null, []);
+			}
+
+			var announcements = results.rss.channel[0].item.map(function(announcement) {
+				var splitLink = announcement.link[0].split('/');
+				return {
+					headline: announcement.title[0],
+					content:  announcement.description[0],
+					date:     new Date(announcement.pubDate[0]),
+					author:   announcement.author[0],
+					aid:      splitLink[splitLink.length - 1]
+				}
+			}).filter(function(announcement) {
+				return (announcement.date > time);
+			});
+
+			return callback(null, announcements);
+		});
+	});
+}
+
 SteamCommunity.prototype.postGroupAnnouncement = function(gid, headline, content, callback) {
 	if(typeof gid === 'string') {
 		gid = new SteamID(gid);
@@ -146,8 +196,73 @@ SteamCommunity.prototype.postGroupAnnouncement = function(gid, headline, content
 			return;
 		}
 
-		if(err || response.statusCode >= 400) {
-			callback(err || new Error("HTTP error " + response.statusCode));
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	})
+};
+
+SteamCommunity.prototype.editGroupAnnouncement = function(gid, aid, headline, content, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+
+	var submitData = {
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/announcements",
+		"form": {
+			"sessionID": this.getSessionID(),
+			"gid": aid,
+			"action": "update",
+			"headline": headline,
+			"body": content,
+			"languages[0][headline]": headline,
+			"languages[0][body]": content,
+			"languages[0][updated]": 1
+		}
+	}
+
+	this.request.post(submitData, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(self._checkHttpError(err, response, callback)) {
+			return;
+		}
+
+		if(self._checkCommunityError(body, callback)) {
+			return;
+		}
+
+		callback(null);
+	})
+};
+
+SteamCommunity.prototype.deleteGroupAnnouncement = function(gid, aid, callback) {
+	if(typeof gid === 'string') {
+		gid = new SteamID(gid);
+	}
+
+	var self = this;
+
+	var submitData = {
+		"uri": "https://steamcommunity.com/gid/" + gid.getSteamID64() + "/announcements/delete/" + aid + "?sessionID=" + this.getSessionID(),
+	}
+
+	this.request.get(submitData, function(err, response, body) {
+		if(!callback) {
+			return;
+		}
+
+		if(self._checkHttpError(err, response, callback)) {
 			return;
 		}
 

components/profile.js

@@ -190,15 +190,6 @@ SteamCommunity.prototype.profileSettings = function(settings, callback) {
 				case 'inventoryGifts':
 					values.inventoryGiftPrivacy = settings[i] ? 1 : 0;
 					break;
-				
-				case 'emailConfirmation': // deprecated
-				case 'tradeConfirmation':
-					values.tradeConfirmationSetting = settings[i] ? 1 : 0;
-					break;
-
-				case 'marketConfirmation':
-					values.marketConfirmationSetting = settings[i] ? 1 : 0;
-					break;
 			}
 		}
 		

components/twofactor.js

@@ -16,11 +16,6 @@ SteamCommunity.prototype.enableTwoFactor = function(callback) {
 			return;
 		}
 
-		// Create a random device ID hash
-		var hash = require('crypto').createHash('sha1');
-		hash.update(self.steamID.getSteamID64());
-		hash = hash.digest('hex');
-
 		self.request.post({
 			"uri": "https://api.steampowered.com/ITwoFactorService/AddAuthenticator/v1/",
 			"form": {
@@ -28,7 +23,7 @@ SteamCommunity.prototype.enableTwoFactor = function(callback) {
 				"access_token": token,
 				"authenticator_time": Math.floor(Date.now() / 1000),
 				"authenticator_type": ETwoFactorTokenType.ValveMobileApp,
-				"device_identifier": 'android:' + hash,
+				"device_identifier": SteamTotp.getDeviceID(self.steamID),
 				"sms_phone_id": "1"
 			},
 			"json": true

examples/edit-group-announcement.js

@@ -0,0 +1,109 @@
+var SteamCommunity = require('../index.js');
+var ReadLine = require('readline');
+var fs = require('fs');
+
+var community = new SteamCommunity();
+var rl = ReadLine.createInterface({
+	"input": process.stdin,
+	"output": process.stdout
+});
+
+rl.question("Username: ", function(accountName) {
+	rl.question("Password: ", function(password) {
+		doLogin(accountName, password);
+	});
+});
+
+function doLogin(accountName, password, authCode, twoFactorCode) {
+	community.login({
+		"accountName": accountName,
+		"password": password,
+		"authCode": authCode,
+		"twoFactorCode": twoFactorCode
+	}, function(err, sessionID, cookies, steamguard) {
+		if(err) {
+			if(err.message == 'SteamGuardMobile') {
+				rl.question("Steam Authenticator Code: ", function(code) {
+					doLogin(accountName, password, null, code);
+				});
+
+				return;
+			}
+
+			if(err.message == 'SteamGuard') {
+				console.log("An email has been sent to your address at " + err.emaildomain);
+				rl.question("Steam Guard Code: ", function(code) {
+					doLogin(accountName, password, code);
+				});
+
+				return;
+			}
+
+			console.log(err);
+			process.exit();
+			return;
+		}
+
+		console.log("Logged on!");
+
+		rl.question("Group ID: ", function(gid) {
+			community.getSteamGroup(gid, function(err, group) {
+				if (err) {
+					console.log(err);
+					process.exit(1);
+				}
+
+				group.getAllAnnouncements(function(err, announcements) {
+
+					if(announcements.length === 0) {
+						return console.log("This group has no announcements");
+					}
+
+					for (var i = announcements.length - 1; i >= 0; i--) {
+						console.log("[%s] %s %s: %s", announcements[i].date, announcements[i].aid, announcements[i].author, announcements[i].content);
+					};
+
+					rl.question("Would you like to delete delete or edit an annoucement? (Type edit/delete): ", function(choice) {
+						rl.question("Annoucement ID: ", function(aid) {
+							if(choice === 'edit') {
+								rl.question("New title: ", function(header) {
+									rl.question("New body: ", function(content) {
+										// EW THE PYRAMID!
+										// Try replace this with delete!
+										editAnnouncement(group, aid, header, content);
+									});
+								});
+							} else {
+								deleteAnnouncement(group, aid);
+							}
+						});
+					});
+				});
+			});
+		});
+	});
+}
+
+function editAnnouncement(group, aid, header, content) {
+	// Actual community method.
+	group.editAnnouncement(aid, header, content, function(error) {
+		if(!error) {
+			console.log("Annoucement edited!");
+		} else {
+			console.log("Unable to edit annoucement! %j", error);
+			process.exit(1);
+		}
+	});
+}
+
+function deleteAnnouncement(group, aid) {
+	// group.deleteAnnouncement(aid);
+	// Or
+	group.deleteAnnouncement(aid, function(err) {
+		if(!err) {
+			console.log("Deleted");
+		} else {
+			console.log("Error deleting announcement.");
+		}
+	})
+}

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "steamcommunity",
-	"version": "3.17.2",
+	"version": "3.18.4",
 	"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",
@@ -13,12 +13,12 @@
 		"url": "https://github.com/DoctorMcKay/node-steamcommunity.git"
 	},
 	"dependencies": {
-		"request":			"^2.61.0",
-		"node-bignumber":	"^1.2.1",
-		"steamid":			"^0.3.1",
-		"xml2js":			"^0.4.11",
-		"cheerio":			"^0.19.0",
-		"async":			"^1.4.2",
-		"steam-totp":		"^1.0.0"
+		"request": "^2.61.0",
+		"node-bignumber": "^1.2.1",
+		"steamid": "^0.3.1",
+		"xml2js": "^0.4.11",
+		"cheerio": "^0.19.0",
+		"async": "^1.4.2",
+		"steam-totp": "^1.3.0"
 	}
 }