prosody-modules
50c4348c2494
mod_twitter/mod_twitter.lua

Find changesets by keywords by author, files, the commit message, revision number or hash, or revset expression.

Software / code / prosody-modules

Comparison

mod_twitter/mod_twitter.lua @ 249:50c4348c2494

mod_twitter: Initial commit.
author dersd <xdersd@gmail.com>
date Sat, 28 Aug 2010 22:19:54 +0400
child 790:4f9cd19c4658
comparison
equal deleted inserted replaced
248:db1b4c6089b6 249:50c4348c2494
1 -- for Prosody
2 -- via dersd
3
4 if module:get_host_type() ~= "component" then
5 error(module.name.." should be loaded as a component, check out http://prosody.im/doc/components", 0);
6 end
7
8 local jid_split = require "util.jid".split;
9 local st = require "util.stanza";
10 local componentmanager = require "core.componentmanager";
11 local datamanager = require "util.datamanager";
12 local timer = require "util.timer";
13 local http = require "net.http";
14 local json = require "json";
15 local base64 = require "util.encodings".base64;
16
17 local component_host = module:get_host();
18 local component_name = module.name;
19 local data_cache = {};
20
21 function print_r(obj)
22 return require("util.serialization").serialize(obj);
23 end
24
25 function send_stanza(stanza)
26 if stanza ~= nil then
27 core_route_stanza(prosody.hosts[component_host], stanza)
28 end
29 end
30
31 function dmsg(jid, msg)
32 module:log("debug", msg or "nil");
33 if jid ~= nil then
34 send_stanza(st.message({to=jid, from=component_host, type='chat'}):tag("body"):text(msg or "nil"):up());
35 end
36 end
37
38 function substring(string, start_string, ending_string)
39 local s_value_start, s_value_finish = nil, nil;
40 if start_string ~= nil then
41 _, s_value_start = string:find(start_string);
42 if s_value_start == nil then
43 -- error
44 return nil;
45 end
46 else
47 return nil;
48 end
49 if ending_string ~= nil then
50 _, s_value_finish = string:find(ending_string, s_value_start+1);
51 if s_value_finish == nil then
52 -- error
53 return nil;
54 end
55 else
56 s_value_finish = string:len()+1;
57 end
58 return string:sub(s_value_start+1, s_value_finish-1);
59 end
60
61 local http_timeout = 30;
62 local http_queue = setmetatable({}, { __mode = "k" }); -- auto-cleaning nil elements
63 data_cache['prosody_os'] = prosody.platform;
64 data_cache['prosody_version'] = prosody.version;
65 local http_headers = {
66 ["User-Agent"] = "Prosody ("..data_cache['prosody_version'].."; "..data_cache['prosody_os']..")" --"ELinks (0.4pre5; Linux 2.4.27 i686; 80x25)",
67 };
68
69 function http_action_callback(response, code, request, xcallback)
70 if http_queue == nil or http_queue[request] == nil then return; end
71 local id = http_queue[request];
72 http_queue[request] = nil;
73 if xcallback == nil then
74 dmsg(nil, "http_action_callback reports that xcallback is nil");
75 else
76 xcallback(id, response, request);
77 end
78 return true;
79 end
80
81 function http_add_action(tid, url, method, post, fcallback)
82 local request = http.request(url, { headers = http_headers or {}, body = http.formencode(post or {}), method = method or "GET" }, function(response, code, request) http_action_callback(response, code, request, fcallback) end);
83 http_queue[request] = tid;
84 timer.add_task(http_timeout, function() http.destroy_request(request); end);
85 return true;
86 end
87
88 local users = setmetatable({}, {__mode="k"});
89 local user = {};
90 user.__index = user;
91 user.dosync = false;
92 user.valid = false;
93 user.data = {};
94
95 function user:login()
96 userdata = datamanager.load(self.jid, component_host, "data");
97 if userdata ~= nil then
98 self.data = userdata;
99 if self.data['_twitter_sess'] ~= nil then
100 http_headers['Cookie'] = "_twitter_sess="..self.data['_twitter_sess']..";";
101 end
102 send_stanza(st.presence({to=self.jid, from=component_host}));
103 self:twitterAction("VerifyCredentials");
104 if self.data.dosync == 1 then
105 self.dosync = true;
106 timer.add_task(self.data.refreshrate, function() return users[self.jid]:sync(); end)
107 end
108 else
109 send_stanza(st.message({to=self.jid, from=component_host, type='chat'}):tag("body"):text("You are not signed in."));
110 end
111 end
112
113 function user:logout()
114 datamanager.store(self.jid, component_host, "data", self.data);
115 self.dosync = false;
116 send_stanza(st.presence({to=self.jid, from=component_host, type='unavailable'}));
117 end
118
119 function user:sync()
120 if self.dosync then
121 table.foreach(self.data.synclines, function(ind, line) self:twitterAction(line.name, {sinceid=line.sinceid}) end);
122 return self.data.refreshrate;
123 end
124 end
125
126 function user:signin()
127 if datamanager.load(self.jid, component_host, "data") == nil then
128 datamanager.store(self.jid, component_host, "data", {login=self.data.login, password=self.data.password, refreshrate=60, dosync=1, synclines={{name='HomeTimeline', sinceid=0}}, syncstatus=0})
129 send_stanza(st.presence{to=self.jid, from=component_host, type='subscribe'});
130 send_stanza(st.presence{to=self.jid, from=component_host, type='subscribed'});
131 end
132 end
133
134 function user:signout()
135 if datamanager.load(self.jid, component_host, "data") ~= nil then
136 datamanager.store(self.jid, component_host, "data", nil);
137 send_stanza(st.presence({to=self.jid, from=component_host, type='unavailable'}));
138 send_stanza(st.presence({to=self.jid, from=component_host, type='unsubscribe'}));
139 send_stanza(st.presence({to=self.jid, from=component_host, type='unsubscribed'}));
140 end
141 end
142
143 local twitterApiUrl = "http://api.twitter.com";
144 local twitterApiVersion = "1";
145 local twitterApiDataType = "json";
146 local twitterActionUrl = function(action) return twitterApiUrl.."/"..twitterApiVersion.."/"..action.."."..twitterApiDataType end;
147 local twitterActionMap = {
148 PublicTimeline = {
149 url = twitterActionUrl("statuses/public_timeline"),
150 method = "GET",
151 needauth = false,
152 },
153 HomeTimeline = {
154 url = twitterActionUrl("statuses/home_timeline"),
155 method = "GET",
156 needauth = true,
157 },
158 FriendsTimeline = {
159 url = twitterActionUrl("statuses/friends_timeline"),
160 method = "GET",
161 needauth = true,
162 },
163 UserTimeline = {
164 url = twitterActionUrl("statuses/friends_timeline"),
165 method = "GET",
166 needauth = true,
167 },
168 VerifyCredentials = {
169 url = twitterActionUrl("account/verify_credentials"),
170 method = "GET",
171 needauth = true,
172 },
173 UpdateStatus = {
174 url = twitterActionUrl("statuses/update"),
175 method = "POST",
176 needauth = true,
177 },
178 Retweet = {
179 url = twitterActionUrl("statuses/retweet/%tweetid"),
180 method = "POST",
181 needauth = true,
182 }
183 }
184
185 function user:twitterAction(line, params)
186 local action = twitterActionMap[line];
187 if action then
188 local url = action.url;
189 local post = {};
190 --if action.needauth and not self.valid and line ~= "VerifyCredentials" then
191 -- return
192 --end
193 if action.needauth then
194 http_headers['Authorization'] = "Basic "..base64.encode(self.data.login..":"..self.data.password);
195 --url = string.gsub(url, "http\:\/\/", string.format("http://%s:%s@", self.data.login, self.data.password));
196 end
197 if params and type(params) == "table" then
198 post = params;
199 end
200 if action.method == "GET" and post ~= {} then
201 url = url.."?"..http.formencode(post);
202 end
203 http_add_action(line, url, action.method, post, function(...) self:twitterActionResult(...) end);
204 else
205 send_stanza(st.message({to=self.jid, from=component_host, type='chat'}):tag("body"):text("Wrong twitter action!"):up());
206 end
207 end
208
209 local twitterActionResultMap = {
210 PublicTimeline = {exec=function(jid, response)
211 --send_stanza(st.message({to=jid, from=component_host, type='chat'}):tag("body"):text(print_r(response)):up());
212 return
213 end},
214 HomeTimeline = {exec=function(jid, response)
215 --send_stanza(st.message({to=jid, from=component_host, type='chat'}):tag("body"):text(print_r(response)):up());
216 return
217 end},
218 FriendsTimeline = {function(jid, response)
219 return
220 end},
221 UserTimeline = {exec=function(jid, response)
222 return
223 end},
224 VerifyCredentials = {exec=function(jid, response)
225 if response ~= nil and response.id ~= nil then
226 users[jid].valid = true;
227 users[jid].id = response.id;
228 end
229 return
230 end},
231 UpdateStatus = {exec=function(jid, response)
232 return
233 end},
234 Retweet = {exec=function(jid, response)
235 return
236 end}
237 }
238
239 function user:twitterActionResult(id, response, request)
240 if request ~= nil and request.responseheaders['set-cookie'] ~= nil and request.responseheaders['location'] ~= nil then
241 --self.data['_twitter_sess'] = substring(request.responseheaders['set-cookie'], "_twitter_sess=", ";");
242 --http_add_action(id, request.responseheaders['location'], "GET", {}, function(...) self:twitterActionResult(...) end);
243 return true;
244 end
245 local result, tmp_json = pcall(function() json.decode(response or "{}") end);
246 if result and id ~= nil then
247 twitterActionResultMap[id]:exec(self.jid, tmp_json);
248 end
249 return true;
250 end
251
252 function iq_success(event)
253 local origin, stanza = event.origin, event.stanza;
254 local reply = data_cache.success;
255 if reply == nil then
256 reply = st.iq({type='result', from=stanza.attr.to or component_host});
257 data_cache.success = reply;
258 end
259 reply.attr.id = stanza.attr.id;
260 reply.attr.to = stanza.attr.from;
261 origin.send(reply);
262 return true;
263 end
264
265 function iq_disco_info(event)
266 local origin, stanza = event.origin, event.stanza;
267 local from = {};
268 from.node, from.host, from.resource = jid_split(stanza.attr.from);
269 local bjid = from.node.."@"..from.host;
270 local reply = data_cache.disco_info;
271 if reply == nil then
272 reply = st.iq({type='result', from=stanza.attr.to or component_host}):query("http://jabber.org/protocol/disco#info")
273 :tag("identity", {category='gateway', type='chat', name=component_name}):up();
274 reply = reply:tag("feature", {var="urn:xmpp:receipts"}):up();
275 reply = reply:tag("feature", {var="http://jabber.org/protocol/commands"}):up();
276 reply = reply:tag("feature", {var="jabber:iq:register"}):up();
277 --reply = reply:tag("feature", {var="jabber:iq:time"}):up();
278 --reply = reply:tag("feature", {var="jabber:iq:version"}):up();
279 --reply = reply:tag("feature", {var="http://jabber.org/protocol/stats"}):up();
280 data_cache.disco_info = reply;
281 end
282 reply.attr.id = stanza.attr.id;
283 reply.attr.to = stanza.attr.from;
284 origin.send(reply);
285 return true;
286 end
287
288 function iq_disco_items(event)
289 local origin, stanza = event.origin, event.stanza;
290 local reply = data_cache.disco_items;
291 if reply == nil then
292 reply = st.iq({type='result', from=stanza.attr.to or component_host}):query("http://jabber.org/protocol/disco#items");
293 data_cache.disco_items = reply;
294 end
295 reply.attr.id = stanza.attr.id;
296 reply.attr.to = stanza.attr.from;
297 origin.send(reply);
298 return true;
299 end
300
301 function iq_register(event)
302 local origin, stanza = event.origin, event.stanza;
303 if stanza.attr.type == "get" then
304 local reply = data_cache.registration_form;
305 if reply == nil then
306 reply = st.iq({type='result', from=stanza.attr.to or component_host})
307 :tag("query", { xmlns="jabber:iq:register" })
308 :tag("instructions"):text("Enter your twitter data"):up()
309 :tag("username"):up()
310 :tag("password"):up();
311 data_cache.registration_form = reply
312 end
313 reply.attr.id = stanza.attr.id;
314 reply.attr.to = stanza.attr.from;
315 origin.send(reply);
316 elseif stanza.attr.type == "set" then
317 local from = {};
318 from.node, from.host, from.resource = jid_split(stanza.attr.from);
319 local bjid = from.node.."@"..from.host;
320 local username, password = "", "";
321 local reply;
322 for _, tag in ipairs(stanza.tags[1].tags) do
323 if tag.name == "remove" then
324 users[bjid]:signout();
325 iq_success(event);
326 return true;
327 end
328 if tag.name == "username" then
329 username = tag[1];
330 end
331 if tag.name == "password" then
332 password = tag[1];
333 end
334 end
335 if username ~= nil and password ~= nil then
336 users[bjid] = setmetatable({}, user);
337 users[bjid].jid = bjid;
338 users[bjid].data.login = username;
339 users[bjid].data.password = password;
340 users[bjid]:signin();
341 users[bjid]:login();
342 end
343 iq_success(event);
344 return true;
345 end
346 end
347
348 function presence_stanza_handler(event)
349 local origin, stanza = event.origin, event.stanza;
350 local to = {};
351 local from = {};
352 local pres = {};
353 to.node, to.host, to.resource = jid_split(stanza.attr.to);
354 from.node, from.host, from.resource = jid_split(stanza.attr.from);
355 pres.type = stanza.attr.type;
356 for _, tag in ipairs(stanza.tags) do pres[tag.name] = tag[1]; end
357 local from_bjid = nil;
358 if from.node ~= nil and from.host ~= nil then
359 from_bjid = from.node.."@"..from.host;
360 elseif from.host ~= nil then
361 from_bjid = from.host;
362 end
363 if pres.type == nil then
364 if users[from_bjid] ~= nil then
365 -- Status change
366 if pres['status'] ~= nil and users[from_bjid]['data']['sync_status'] then
367 users[from_bjid]:twitterAction("UpdateStatus", {status=pres['status']});
368 end
369 else
370 -- User login request
371 users[from_bjid] = setmetatable({}, user);
372 users[from_bjid].jid = from_bjid;
373 users[from_bjid]:login();
374 end
375 origin.send(st.presence({to=from_bjid, from=component_host}));
376 elseif pres.type == 'subscribe' and users[from_bjid] ~= nil then
377 origin.send(st.presence{to=from_bjid, from=component_host, type='subscribed'});
378 elseif pres.type == 'unsubscribed' and users[from_bjid] ~= nil then
379 users[from_bjid]:logout();
380 users[from_bjid]:signout();
381 users[from_bjid] = nil;
382 elseif pres.type == 'unavailable' and users[from_bjid] ~= nil then
383 users[from_bjid]:logout();
384 users[from_bjid] = nil;
385 end
386 return true;
387 end
388
389 function confirm_message_delivery(event)
390 local reply = st.message({id=event.stanza.attr.id, to=event.stanza.attr.from, from=event.stanza.attr.to or component_host}):tag("received", {xmlns = "urn:xmpp:receipts"});
391 origin.send(reply);
392 return true;
393 end
394
395 function message_stanza_handler(event)
396 local origin, stanza = event.origin, event.stanza;
397 local to = {};
398 local from = {};
399 local msg = {};
400 to.node, to.host, to.resource = jid_split(stanza.attr.to);
401 from.node, from.host, from.resource = jid_split(stanza.attr.from);
402 local bjid = nil;
403 if from.node ~= nil and from.host ~= nil then
404 from_bjid = from.node.."@"..from.host;
405 elseif from.host ~= nil then
406 from_bjid = from.host;
407 end
408 local to_bjid = nil;
409 if to.node ~= nil and to.host ~= nil then
410 to_bjid = to.node.."@"..to.host;
411 elseif to.host ~= nil then
412 to_bjid = to.host;
413 end
414 for _, tag in ipairs(stanza.tags) do
415 msg[tag.name] = tag[1];
416 if tag.attr.xmlns == "urn:xmpp:receipts" then
417 confirm_message_delivery({origin=origin, stanza=stanza});
418 end
419 -- can handle more xmlns
420 end
421 -- Now parse the message
422 if stanza.attr.to == component_host then
423 if msg.body == "!myinfo" then
424 if users[from_bjid] ~= nil then
425 origin.send(st.message({to=stanza.attr.from, from=component_host, type='chat'}):tag("body"):text(print_r(users[from_bjid])):up());
426 end
427 end
428 -- Other messages go to twitter
429 user:twitterAction("UpdateStatus", {status=msg.body});
430 else
431 -- Message to uid@host/resource
432 end
433 return true;
434 end
435
436 module:hook("presence/host", presence_stanza_handler);
437 module:hook("message/host", message_stanza_handler);
438
439 module:hook("iq/host/jabber:iq:register:query", iq_register);
440 module:hook("iq/host/http://jabber.org/protocol/disco#info:query", iq_disco_info);
441 module:hook("iq/host/http://jabber.org/protocol/disco#items:query", iq_disco_items);
442 module:hook("iq/host", function(data)
443 -- IQ to a local host recieved
444 local origin, stanza = data.origin, data.stanza;
445 if stanza.attr.type == "get" or stanza.attr.type == "set" then
446 return module:fire_event("iq/host/"..stanza.tags[1].attr.xmlns..":"..stanza.tags[1].name, data);
447 else
448 module:fire_event("iq/host/"..stanza.attr.id, data);
449 return true;
450 end
451 end);
452
453 module.unload = function()
454 componentmanager.deregister_component(component_host);
455 end
456 component = componentmanager.register_component(component_host, function() return; end);