def parse(self, handler, request, path=None):
""" parse request/response into a WebEvent. """
self.handler = handler
self.request = request
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
try: how = request.arguments['how'][0]
except KeyError: how = "background"
if not how: how = "background"
self.how = how
if self.how == "undefined": self.how = "overwrite"
logging.warn("web - how is %s" % self.how)
input = request.headers.get('content') or request.headers.get('cmnd')
if not input:
try: input = request.arguments['content'] or request.arguments['cmnd']
except KeyError: pass
self.isweb = True
if not input: logging.warn("input is %s" % input) ; raise NoInput(input)
self.txt = fromenc(input[0].strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
self.createdfrom = str(handler)
logging.debug('tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def parseAPI(self, handler, apitype, path):
""" parse request/response into a WebEvent. """
#logging.warn(dir(handler))
#logging.warn(dir(handler.request))
#logging.warn(request.arguments)
#logging.warn(request.body)
self.handler = handler
self.request = handler.request
self.query = self.request.query
self.upath = path
self.apitype = apitype
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
input = path
self.isweb = True
logging.warn("input is %s" % input)
if not input: raise NoInput(input)
self.txt = fromenc(input.strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
self.createdfrom = str(handler)
logging.debug('tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def handle_presence(self, data, *args, **kwargs):
""" message handler. """
try:
p = Presence()
p.parse(data, self)
frm = p.fromm
nickk = ""
nick = p.nick
if self.cfg.user in frm: self.pongcheck = True
if nick:
self.userhosts[nick] = stripped(frm)
nickk = nick
jid = p.fromm
if nickk and jid and self.cfg.fulljids:
channel = p.channel
if channel not in self.jids:
self.jids[channel] = {}
self.jids[channel][nickk] = jid
self.userhosts[nickk] = stripped(jid)
logging.info('%s - setting jid of %s (%s) to %s' % (self.cfg.name, nickk, channel, self.userhosts[nickk]))
if p.type == 'subscribe':
pres = Presence({'to': p.fromm, 'type': 'subscribed'})
self.send(pres)
pres = Presence({'to': p.fromm, 'type': 'subscribe'})
self.send(pres)
nick = p.resource
if p.type != 'unavailable':
p.joined = True
p.type = 'available'
elif self.cfg.user in p.userhost:
try:
del self.jids[p.channel]
logging.debug('%s - removed %s channel jids' % (self.cfg.name, p.channel))
except KeyError: pass
else:
try:
del self.jids[p.channel][p.nick]
logging.debug('%s - removed %s jid' % (self.cfg.name, p.nick))
except KeyError: pass
self.put(p)
except Exception as ex: handle_exception()
def parsesocket(self, handler, message):
""" parse request/response into a WebEvent. """
self.handler = handler
try: data = LazyDict(json.loads(message))
except Exception as ex: logging.error("failed to parse data: %s - %s" % (message, str(ex))) ; return self
logging.info("incoming: %s" % message)
self.div = data.target
self.userhost = tornado.escape.xhtml_escape(handler.current_user)
if not self.userhost: raise Exception("no current user.")
self.isweb = True
input = data.cmnd
self.how = data.how or self.how
logging.warn("cmnd is %s - how is %s" % (input, self.how))
self.txt = fromenc(input.strip(), self.bot.encoding)
self.nick = self.userhost.split("@")[0]
self.auth = fromenc(self.userhost)
self.stripped = stripped(self.auth)
self.channel = stripped(self.userhost)
self.createdfrom = str(handler)
logging.debug('tornado - parsed - %s - %s' % (self.txt, self.userhost))
self.prepare()
return self
def handle_message(self, data, *args, **kwargs):
""" message handler. """
if '<delay xmlns="urn:xmpp:delay"' in str(data): logging.debug("ignoring delayed message") ; return
m = Message()
m.parse(data, self)
if m.type == 'groupchat' and m.subject:
logging.debug("%s - checking topic" % self.cfg.name)
self.topiccheck(m)
nm = Message(m)
callbacks.check(self, nm)
return
if m.isresponse:
logging.debug("%s - message is a response" % self.cfg.name)
return
jid = None
m.origjid = m.jid
if self.cfg.fulljids and not m.msg:
utarget = self.userhosts.get(m.nick)
if utarget: m.userhost = m.jid = m.auth = stripped(utarget)
else: m.userhost = m.jid
if m.msg: m.userhost = stripped(m.userhost)
logging.debug("using %s as userhost" % m.userhost)
m.dontbind = False
self.put(m)
