Example #1
0
 def makeDataElement(self):
     """ Returns an XML Element that can be put into a jabber:x:avatar IQ stanza. """
     data = Element((None, "data"))
     data["mimetype"] = "image/png"
     data.addContent(
         base64.encodestring(self.getImageData()).replace("\n", ""))
     return data
	def sendCompletedForm(self, el, sessionid=None):
		to = el.getAttribute('from')
		ID = el.getAttribute('id')
		ulang = utils.getLang(el)
		
		iq = Element((None, 'iq'))
		iq.attributes = {'to': to, 'from': config.jid, 'type': 'result'}
		if ID:
			iq.attributes['id'] = ID
		command = iq.addElement('command')
		command.attributes = {
			'node': 'settings', 
			'xmlns': globals.COMMANDS, 
			'status': 'completed'
		}
		if sessionid:
			command.attributes['sessionid'] = sessionid
		else:
			command.attributes['sessionid'] = self.pytrans.makeMessageID()

		note = command.addElement('note', None, lang.get('settings_changed'))
		note.attributes['type'] = 'info'
		
		x = command.addElement('x')
		x.attributes = {'xmlns': 'jabber:x:data', 'type': 'form'}
		x.addElement('title', None, lang.get('command_Settings'))
		x.addElement('instructions', None, lang.get('settings_changed'))
		
		self.pytrans.send(iq)
	def sendTune(self, to=None, fro=None, musicinfo=None, stop=False):
		"""
		send tune to user
		"""
		LogEvent(INFO)
		el = Element((None, "message"))
		el.attributes["id"] = self.pytrans.makeMessageID()
		if fro:
			el.attributes["from"] = fro
	
		e = el.addElement("event")
		e.attributes["xmlns"] = globals.PUBSUBEVENT
		
		items = e.addElement("items")
		items.attributes["node"] = globals.TUNE
		
		item = items.addElement("item")
		item.attributes["id"] = self.pytrans.makeMessageID()
			
		t = item.addElement("tune")
		t.attributes["xmlns"] = globals.TUNE
			
		if not stop:
			if musicinfo and len(musicinfo) > 0:
				for key in musicinfo:
					if key in ('artist', 'length', 'rating', 'source', 'title', 'track', 'uri'):
						value = musicinfo[key]
						if value:
							t_key = t.addElement(key)
							t_key.addContent(value)
		
		for res in self.pytrans.sessions[to].resourceList: # send to every resource
			el.attributes["to"] = to + '/' + res
			self.pytrans.send(el)
Example #4
0
File: avatar.py Project: 2mf/pyicqt
 def makeDataElement(self):
     """ Returns an XML Element that can be put into a jabber:x:avatar IQ stanza. """
     data = Element((None, "data"))
     data["mimetype"] = "image/png"
     data.addContent(
         base64.encodestring(self.getImageData()).replace("\n", ""))
     return data
Example #5
0
    def _onStartElement(self, name, attrs):
        print '_onStartElement', name, attrs
        # Generate a qname tuple from the provided name.  See
        # http://docs.python.org/library/pyexpat.html#xml.parsers.expat.ParserCreate
        # for an explanation of the formatting of name.
        qname = name.rsplit(" ", 1)
        if len(qname) == 1:
            qname = ('', name)

        # Process attributes
        for k, v in attrs.items():
            if " " in k:
                aqname = k.rsplit(" ", 1)
                attrs[(aqname[0], aqname[1])] = v
                del attrs[k]

        # Construct the new element
        e = Element(qname, self.defaultNsStack[-1], attrs, self.localPrefixes)
        self.localPrefixes = {}

        # Document already started
        if self.documentStarted == 1:
            if self.currElem != None:
                self.currElem.children.append(e)
                e.parent = self.currElem
            self.currElem = e

        # New document
        else:
            self.documentStarted = 1
            self.DocumentStartEvent(e)
Example #6
0
    def toElement(self):
        el = Element((None, 'actions'))
        if self.default:
            el['execute'] = self.default

        [el.addElement(a) for a in self.actions]
        return el
        def _send():
            mt = getToolByName(portal, "portal_membership", None)
            message = Element((None, "message"))
            message["id"] = getRandomId()
            message["from"] = self.xmlstream.factory.authenticator.jid.full()
            message["to"] = to.userhost()
            x = message.addElement((NS_ROSTER_X, "x"))
            for jid in items:
                if to == jid:
                    continue

                member_id = users.unescapeNode(jid.user)
                if mt is not None and mt.getMemberInfo(member_id):
                    info = mt.getMemberInfo(member_id)
                    fullname = info.get("fullname", member_id).decode("utf-8")
                else:
                    log.warn("Could not get user fullname: %s" % member_id)
                    fullname = ""

                item = x.addElement("item")
                item["action"] = "add"
                item["jid"] = jid.userhost()
                item["name"] = fullname
                if group:
                    item.addElement("group", content=group)
            self.xmlstream.send(message)
Example #8
0
    def removeListEntry(self, type, jabberID, legacyID):
        """ Removes a legacy ID entry from a list in
		the XDB, based off the type and jabberID you provide. """
        if type != "roster": return
        xdbns = XDBNS_PREFIX + type
        list = self.request(jabberID, xdbns)
        if list == None:
            list = Element((None, "aimtrans"))
            list.attributes["xmlns"] = xdbns

        buddies = None
        for child in list.elements():
            try:
                if child.name == "buddies":
                    buddies = child
                    break
            except AttributeError:
                continue

        if buddies == None:
            buddies = list.addElement("buddies")

        # Remove the existing element
        for child in buddies.elements():
            try:
                if child.getAttribute("name") == legacyID:
                    buddies.children.remove(child)
            except AttributeError:
                continue

        self.set(jabberID, xdbns, list)
	def sendMood(self, to=None, fro=None, mood=None, text=None, action=None):
		"""
		send mood to user
		"""
		LogEvent(INFO)
		el = Element((None, "message"))
		el.attributes["id"] = self.pytrans.makeMessageID()
		if fro:
			el.attributes["from"] = fro
	
		e = el.addElement("event")
		e.attributes["xmlns"] = globals.PUBSUBEVENT
		
		items = e.addElement("items")
		items.attributes["node"] = globals.MOOD
		
		if action == 'retract':
			r = items.addElement("retract")
			r.attributes["id"] = self.pytrans.makeMessageID()
		else:
			item = items.addElement("item")
			item.attributes["id"] = self.pytrans.makeMessageID()
			
			m = item.addElement("mood")
			m.attributes["xmlns"] = globals.MOOD
			
			if mood:
				m.addElement(mood)
			if text:
				t = m.addElement("text")
				t.addContent(text)

		for res in self.pytrans.sessions[to].resourceList: # send to every resource
			el.attributes["to"] = to + '/' + res
			self.pytrans.send(el)
Example #10
0
 def toElement(self):
     el = Element((collab.COLLAB_NS, 'portfolio'))
     el.addElement('name', content=self.name)
     ass_el = el.addElement('assets')
     for a in self.assets:
         ass_el.addChild(a.toElement())
     return el
class Device(Element):
    '''
    classdocs
    '''
    def __init__(self, deviceName, rootUri, feeds=None, tags=None):
        Element.__init__(self, (None, 'device'))
        self._deviceName = Element((None, 'name'))
        self._deviceName.addContent(deviceName)
        self.addChild(self._deviceName)

        self._rootUri = Element((None, 'rootUri'))
        self._rootUri.addContent(rootUri)
        self.addChild(self._rootUri)

        self._feeds = []
        if feeds is not None:
            for f in feeds:
                self._feeds.append(f)
                self.addChild(f)

        self._tags = []
        if tags is not None:
            for t in tags:
                tag = Tag(t)
                self.addChild(tag)
                self._tags.append(tag)

    def addFeed(self, feed):
        self._feeds.append(feed)
        self.addChild(feed)

    def addTag(self, tag):
        eTag = Tag(tag)
        self._tags.append(eTag)
        self.addChild(eTag)
Example #12
0
        def _send():
            mt = getToolByName(portal, 'portal_membership', None)
            message = Element((
                None,
                "message",
            ))
            message["id"] = getRandomId()
            message["from"] = self.xmlstream.factory.authenticator.jid.full()
            message["to"] = to.userhost()
            x = message.addElement((NS_ROSTER_X, 'x'))
            for jid in items:
                if to == jid:
                    continue

                member_id = users.unescapeNode(jid.user)
                if mt is not None and mt.getMemberInfo(member_id):
                    info = mt.getMemberInfo(member_id)
                    fullname = info.get('fullname', member_id).decode('utf-8')
                else:
                    log.warn('Could not get user fullname: %s' % member_id)
                    fullname = ''

                item = x.addElement('item')
                item["action"] = 'add'
                item["jid"] = jid.userhost()
                item["name"] = fullname
                if group:
                    item.addElement('group', content=group)
            self.xmlstream.send(message)
Example #13
0
File: utils.py Project: wyn/collab
def getRandomPortfolio(min_size=10):
    portfolio = Element((collab.COLLAB_NS, 'portfolio'))
    #assets
    assets = portfolio.addElement('assets')
    no_assets = random.randrange(min_size,20)
    no_issuers = int(no_assets/ratio)
    for i in xrange(no_assets):
        a = assets.addElement('asset')
        a.addElement('id').addContent(str(i))
        a.addElement('name').addContent('asset%i' % i)
        a.addElement('default_probability').addContent(str(float(i)/div))
    #issuers
    issuers = portfolio.addElement('issuers')
    for i in xrange(no_issuers):
        iss = issuers.addElement('issuer')
        iss.addElement('id').addContent(str(i))
        iss.addElement('name').addContent('issuer%i' % i)
        fs = iss.addElement('factors')
        for j in xrange(random.randrange(1, 5)):
            f = fs.addElement('factor')
            f.addElement('name').addContent('factor%i' % j)
            f.addElement('weight').addContent(str(float(j)/div))
    #asset issuer map
    aimap = portfolio.addElement('asset_issuer_map')
    for i in xrange(no_assets):
        a = aimap.addElement('asset')
        a.addElement('id').addContent(str(i))
        a.addElement('issuer').addElement('id').addContent(str(i%no_issuers))

    return portfolio
Example #14
0
File: utils.py Project: wyn/collab
def getPortfolio():
    portfolio = Element((collab.COLLAB_NS, 'portfolio'))
    #assets
    assets = portfolio.addElement('assets')
    for i in xrange(num_assets):
        a = assets.addElement('asset')
        a.addElement('id').addContent(str(i))
        a.addElement('name').addContent('asset%i' % i)
        a.addElement('default_probability').addContent(str(float(i)/div))
    #issuers
    issuers = portfolio.addElement('issuers')
    for i in xrange(num_issuers):
        iss = issuers.addElement('issuer')
        iss.addElement('id').addContent(str(i))
        iss.addElement('name').addContent('issuer%i' % i)
        fs = iss.addElement('factors')
        for j in xrange(num_factors):
            f = fs.addElement('factor')
            f.addElement('name').addContent('factor%i' % j)
            f.addElement('weight').addContent(str(float(j)/div))
    #asset issuer map
    aimap = portfolio.addElement('asset_issuer_map')
    for i in xrange(num_assets):
        a = aimap.addElement('asset')
        a.addElement('id').addContent(str(i))
        a.addElement('issuer').addElement('id').addContent(str(i%num_issuers))

    return portfolio
Example #15
0
    def onIq(self, element: Element):
        source = JID(element.getAttribute("from"))
        recipient = JID(element.getAttribute("to"))
        identification = element.getAttribute("id")
        iqType = element.getAttribute("type")

        print("IqReceived " + source.full() + " -> " + recipient.full() + ": " + iqType)

        # Process component iq
        if recipient.full() == self.h2x.config.JID:
            self.componentIq(element, source, identification, iqType)
            return

            # Process user iq
        if self.h2x.isHangUser(recipient):
            self.userIq(element, source, recipient, identification, iqType)
            return

            # TODO: Can we send something like wrong request?
        self.__sendIqError(
            recipient=source.full(),
            sender=recipient.full(),
            identification=identification,
            errorType="cancel",
            condition="service-unavailable",
        )
Example #16
0
    def test_fromElement_bad(self):
        el = Element((collab.COLLAB_NS, 'wrong'))
        el.addElement('runs', content='100')

        def doIt():
            p = simulation.Progress.fromElement(el)
        self.assertRaises(simulation.InvalidProgressError, doIt)
Example #17
0
    def test_fromElement_notTopNode(self):
        el = Element(('http://jabber.org/protocol/pubsub#event', 'item'))
        prog = el.addElement('progress', defaultUri=collab.COLLAB_NS)
        prog.addElement('runs', content='100')

        p = simulation.Progress.fromElement(el)
        self.assertEquals(p.runs, 100)
Example #18
0
    def toEtree(self):
        msg = Element(('jabber:client', 'iq'))
        msg['type'] = self.type
        msg['id'] = self.id
        msg['from'] = self.from_
        msg['to'] = self.to

        if self.type == 'result':
            ecm_message = msg.addElement('ecm_message')
            ecm_message['version'] = str(AGENT_VERSION_PROTOCOL)
            ecm_message['core'] = str(AGENT_VERSION_CORE)
            ecm_message['command'] = self.command
            ecm_message['signature'] = self.signature

            result = ecm_message.addElement('result')
            result['retvalue'] = self.retvalue
            result['timed_out'] = self.timed_out
            result['partial'] = self.partial

            # compress out
            result.addElement('gzip_stdout').addContent(base64.b64encode(zlib.compress(self.stdout)))
            result.addElement('gzip_stderr').addContent(base64.b64encode(zlib.compress(self.stderr)))
            del ecm_message

        return msg
Example #19
0
    def test_fromElement_ignoresNonData(self):
        name = 'bender'
        el = Element((collab.COLLAB_NS, 'distributions'))
        h = el.addElement('histogram')
        h['name'] = name
        for i in xrange(10):
            if i%2:
                d_el = h.addElement('ignored')
                d_el['point'] = str(i)
                d_el['value'] = str(2*i)
            else:
                d_el = h.addElement('data')
                d_el['point'] = str(i)
                d_el['value'] = str(2*i)

        d = simulation.Distributions.fromElement(el)
        self.assertTrue(name in d.histograms)
        self.assertEquals(len(d.histograms), 1)
        hist = d.histograms[name]
        
        for i in xrange(10):
            if i%2:
                self.assertTrue(i not in hist)
            else:
                self.assertTrue(i in hist)
                self.assertEquals(hist[i], 2*i)
Example #20
0
    def test_fromElement(self):
        el = Element((collabNs, 'asset'))
        el.addElement('name', content='ass')
        el.addElement('dp', content='0.1')
        el.addElement('recovery', content='0.1')
        el.addElement('notional', content='200.0')

        i_el = el.addElement('issuer')
        i_el.addElement('name', content='iss')
        fs_el = i_el.addElement('factors')
        f1_el = fs_el.addElement('factor')
        f1_el.addElement('name', content='f1')
        f1_el.addElement('weight', content='0.1')
        f2_el = fs_el.addElement('factor')
        f2_el.addElement('name', content='f2')
        f2_el.addElement('weight', content='0.2')

        ass = portfolio.Asset.fromElement(el)
        self.assertEquals(ass.name, 'ass')
        self.assertEquals(ass.dp, 0.1)       
        self.assertEquals(ass.recovery, 0.1)
        self.assertEquals(ass.notional, 200.0)       

        i = ass.issuer
        self.assertEquals(i.name, 'iss')
        
        fs = i.factors
        self.assertEquals(len(fs), 2)

        self.assertTrue(checkFactor('f1', 0.1, fs))
        self.assertTrue(checkFactor('f2', 0.2, fs))
Example #21
0
 def setUp(self):
     # Build element:
     # <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
     #     somecontent
     #     <bar>
     #        <foo>
     #         <gar>DEF</gar>
     #        </foo>
     #     </bar>
     #     somemorecontent
     #     <bar attrib2="value2">
     #        <bar>
     #          <foo/>
     #          <gar>ABC</gar>
     #        </bar>
     #     <bar/>
     # </foo>
     self.e = Element(("testns", "foo"))
     self.e["attrib1"] = "value1"
     self.e["attrib3"] = "user@host/resource"
     self.e.addContent("somecontent")
     self.bar1 = self.e.addElement("bar")
     self.subfoo = self.bar1.addElement("foo")
     self.gar1 = self.subfoo.addElement("gar")
     self.gar1.addContent("DEF")
     self.e.addContent("somemorecontent")
     self.bar2 = self.e.addElement("bar")
     self.bar2["attrib2"] = "value2"
     self.bar3 = self.bar2.addElement("bar")
     self.subfoo2 = self.bar3.addElement("foo")
     self.gar2 = self.bar3.addElement("gar")
     self.gar2.addContent("ABC")
     self.bar4 = self.e.addElement("bar")
Example #22
0
        def gotStreamhost(host):
            for streamhost in streamhosts:
                if streamhost[1] == host:
                    jid = streamhost[0]
                    break
            else:
                LogEvent(WARN)
                return errOut()

            for connector in factory.connectors:
                # Stop any other connections
                try:
                    connector.stopConnecting()
                except error.NotConnectingError:
                    pass

            if factory.streamHostTimeout:
                factory.streamHostTimeout.cancel()
                factory.streamHostTimeout = None

            iq = Element((None, "iq"))
            iq["type"] = "result"
            iq["from"] = toj.full()
            iq["to"] = froj.full()
            iq["id"] = ID
            query = iq.addElement("query")
            query["xmlns"] = disco.S5B
            streamhost = query.addElement("streamhost-used")
            streamhost["jid"] = jid
            self.pytrans.send(iq)
Example #23
0
    def test_onGotDistribution(self):
        self.dm.broadcastLogs = Mock()
        self.dm.handleDistribution = Mock(side_effect=utils.good_side_effect('lush'))
        self.dm._errback = Mock(side_effect=utils.good_side_effect('err logged'))

        item = Element((pubsub.NS_PUBSUB_EVENT, 'item'))
        item['id'] = str(1)
        params = sim.Parameters(run_id='1', cmd='results')
        params_el = params.toElement()
        progress = sim.Progress(200)
        params_el.addChild(progress.toElement())
        dist = sim.Distributions()
        hist = defaultdict(int)
        hist[1] = 1
        hist[2] = 2
        dist.combine('a', hist)
        params_el.addChild(dist.toElement())
        item.addChild(params_el)

        lg = sim.Logger()
        d = self.dm.onGotDistribution(params, item, lg)

        def check(data):
            self.assertFalse(self.dm.broadcastLogs.called)
            self.assertEquals(self.dm.handleDistribution.call_count, 1)
            self.assertFalse(self.dm._errback.called)

        d.addCallback(check)
        self.sch.clock.pump([1,1,1])
        return d
Example #24
0
	def removeListEntry(self, type, jabberID, legacyID):
		""" Removes a legacy ID entry from a list in
		the XDB, based off the type and jabberID you provide. """
		if type != "roster": return
		xdbns = XDBNS_PREFIX+type
		list = self.request(jabberID, xdbns)
		if list == None:
			list = Element((None, "aimtrans"))
			list.attributes["xmlns"] = xdbns

		buddies = None
		for child in list.elements():
			try:
				if child.name == "buddies":
					buddies = child
					break
			except AttributeError:
				continue

		if buddies == None:
			buddies = list.addElement("buddies")

		# Remove the existing element
		for child in buddies.elements():
			try:
				if child.getAttribute("name") == legacyID:
					buddies.children.remove(child)
			except AttributeError:
				continue

		self.set(jabberID, xdbns, list)
Example #25
0
 def toElement(self):
     el = Element((collab.COLLAB_NS, 'issuer'))
     el.addElement('name', content=self.name)
     factors = el.addElement('factors')
     for f in self.factors:
         factors.addChild(f.toElement())
     return el
    def test_onGotStartSimulation_noPortfolio(self):
        run_id = '1'
        item = Element((pubsub.NS_PUBSUB_EVENT, 'item'))
        item['id'] = str(run_id)
        params = sim.Parameters(run_id=run_id, cmd='info')
        params_el = item.addChild(params.toElement())
        logger = sim.Logger()

        self.cds.broadcastLogs = Mock(side_effect=utils.good_side_effect('done'))
        self.cds.broadcastResults = Mock()
        self.cds.simulatorFactory = MagicMock()
        self.cds._errback = Mock()

        gen = self.cds.onGotStartSimulation(params, item, logger)
        d = gen.next()

        def check(data):
            self.cds.broadcastLogs.assert_called_once_with(logger, params)
            self.assertFalse(self.cds.broadcastResults.called)
            self.assertFalse(self.cds.simulatorFactory.__getitem__.called)
            self.assertFalse(self.cds._errback.called)

        d.addCallback(check)
        self.assertRaises(StopIteration, gen.next)
        return d
Example #27
0
    def test_toElement(self):
        p = simulation.Progress(100)
        el = p.toElement()

        expected = Element((collab.COLLAB_NS, 'progress'))
        expected.addElement('runs', content='100')

        self.assertEquals(el.toXml(), expected.toXml())
Example #28
0
    def test_Issuer_fromElement_factorsButNoneInThere(self):
        expected = Element((collabNs, 'issuer'))
        expected.addElement('name', content='iss')
        fs_el = expected.addElement('factors')

        i = portfolio.Issuer.fromElement(expected)
        self.assertEquals(i.name, 'iss')
        self.assertEquals(i.factors, set())
Example #29
0
    def test_toElement(self):
        n = Note('bla', 'error')

        el = Element((None, 'note'))
        el['type'] = 'error'
        el.addContent('bla')

        self.assertEquals(n.toElement().toXml(), el.toXml())
Example #30
0
 def list_movies(self):
     request = Element((None, 'movie_list'))
     for movie in movies:
         m = request.addElement('movie')
         m['id_movie'] = movie.id_movie
         m['title'] = movie.title
         m['size'] = str(movie.size)
     self.sendObject(request)
Example #31
0
    def test_fromElement_bad(self):
        el = Element((None, 'note'))
        el['type'] = 'wrong'
        el.addContent('bla')
        n = Note.fromElement(el)

        self.assertEquals(n.note_type, 'warn')
        self.assertEquals(n.content, 'bla')
Example #32
0
    def test_fromElement_noAssets(self):
        el = Element((collabNs, 'portfolio'))
        el.addElement('name', content='port')

        def doIt():
            p = portfolio.Portfolio.fromElement(el)

        self.assertRaises(portfolio.InvalidPortfolioError, doIt)
Example #33
0
    def test_fromElement(self):
        el = Element((None, 'note'))
        el['type'] = 'error'
        el.addContent('bla')
        n = Note.fromElement(el)

        self.assertEquals(n.note_type, 'error')
        self.assertEquals(n.content, 'bla')
Example #34
0
    def test_fromElement_noWeight(self):
        el = Element((collabNs, 'factor'))
        el.addElement('name', content='fac')

        def doIt():
            f = portfolio.Factor.fromElement(el)

        self.assertRaises(portfolio.InvalidFactorError, doIt)
Example #35
0
	def makePhotoElement(self):
		""" Returns an XML Element that can be put into the vCard. """
		photo = Element((None, "PHOTO"))
		type = photo.addElement("TYPE")
		type.addContent("image/png")
		binval = photo.addElement("BINVAL")
		binval.addContent(base64.encodestring(self.getImageData()).replace("\n", ""))
		return photo
Example #36
0
    def test_fromElement(self):
        el = Element((collabNs, 'factor'))
        el.addElement('name', content='fac')
        el.addElement('weight', content='0.5')

        f = portfolio.Factor.fromElement(el)
        self.assertEquals(f.name, 'fac')
        self.assertEquals(f.weight, 0.5)
Example #37
0
 def list_movies(self):
     request = Element((None, 'movie_list'))
     for movie in movies.get_movie_dict():
         m = request.addElement('movie')
         m['id_movie'] = movie.get_id()
         m['title'] = movie.get_title()
         m['size'] = str(movie.get_size())
     self.sendObject(request)
Example #38
0
	def successReply(self, incoming):
		reply = Element((None, "iq"))
		reply.attributes["type"] = "result"
		ID = incoming.getAttribute("id")
		if(ID): reply.attributes["id"] = ID
		reply.attributes["from"] = config.jid
		reply.attributes["to"] = incoming.getAttribute("from")
		self.pytrans.send(reply)
Example #39
0
    def test_fromElement_noAssetsInAssetsElement(self):
        el = Element((collabNs, 'portfolio'))
        el.addElement('name', content='port')
        assets_el = el.addElement('assets')

        p = portfolio.Portfolio.fromElement(el)
        self.assertEquals(p.name, 'port')
        self.assertEquals(p.assets, set())
Example #40
0
 def setUp(self):
     # Build element:
     # <foo xmlns='testns' attrib1='value1' attrib3="user@host/resource">
     #     somecontent
     #     <bar>
     #        <foo>
     #         <gar>DEF</gar>
     #        </foo>
     #     </bar>
     #     somemorecontent
     #     <bar attrib2="value2">
     #        <bar>
     #          <foo/>
     #          <gar>ABC</gar>
     #        </bar>
     #     <bar/>
     #     <bar attrib4='value4' attrib5='value5'>
     #        <foo/>
     #        <gar>JKL</gar>
     #     </bar>
     #     <bar attrib4='value4' attrib5='value4'>
     #        <foo/>
     #        <gar>MNO</gar>
     #     </bar>
     #     <bar attrib4='value4' attrib5='value6'/>
     # </foo>
     self.e = Element(("testns", "foo"))
     self.e["attrib1"] = "value1"
     self.e["attrib3"] = "user@host/resource"
     self.e.addContent("somecontent")
     self.bar1 = self.e.addElement("bar")
     self.subfoo = self.bar1.addElement("foo")
     self.gar1 = self.subfoo.addElement("gar")
     self.gar1.addContent("DEF")
     self.e.addContent("somemorecontent")
     self.bar2 = self.e.addElement("bar")
     self.bar2["attrib2"] = "value2"
     self.bar3 = self.bar2.addElement("bar")
     self.subfoo2 = self.bar3.addElement("foo")
     self.gar2 = self.bar3.addElement("gar")
     self.gar2.addContent("ABC")
     self.bar4 = self.e.addElement("bar")
     self.bar5 = self.e.addElement("bar")
     self.bar5["attrib4"] = "value4"
     self.bar5["attrib5"] = "value5"
     self.subfoo3 = self.bar5.addElement("foo")
     self.gar3 = self.bar5.addElement("gar")
     self.gar3.addContent("JKL")
     self.bar6 = self.e.addElement("bar")
     self.bar6["attrib4"] = "value4"
     self.bar6["attrib5"] = "value4"
     self.subfoo4 = self.bar6.addElement("foo")
     self.gar4 = self.bar6.addElement("gar")
     self.gar4.addContent("MNO")
     self.bar7 = self.e.addElement("bar")
     self.bar7["attrib4"] = "value4"
     self.bar7["attrib5"] = "value6"
Example #41
0
 def leaveChatRoom(self, jid):
     if '/' not in jid:
         jid += '/' + self.SERVICECONFIG.JABBER_CHAT_NICK
     presence = Element((None, 'presence'))
     presence['from'] = self.jid.userhost()
     presence['to'] = jid
     presence['type'] = 'unavailable'
     log('sending leave: %s' % presence.toXml())
     self.xmlstream.send(presence)
Example #42
0
 def makePhotoElement(self):
     """ Returns an XML Element that can be put into the vCard. """
     photo = Element((None, "PHOTO"))
     type = photo.addElement("TYPE")
     type.addContent("image/png")
     binval = photo.addElement("BINVAL")
     binval.addContent(
         base64.encodestring(self.getImageData()).replace("\n", ""))
     return photo
Example #43
0
    def streamStarted(self, rootelem):
        # Create handshake
        hs = Element(("jabber:component:accept", "handshake"))
        hs.addContent(xmlstream.hashPassword(self.xmlstream.sid,
                                             self.password))

        # Setup observer to watch for handshake result
        self.xmlstream.addOnetimeObserver("/handshake", self._handshakeEvent)
        self.xmlstream.send(hs)
Example #44
0
	def sendChatStateNotification(self, to, fro, state):
		""" Sends the user the contact's chat state status """
		if self.chatStateUser:
			LogEvent(INFO, self.jabberID)
			el = Element((None, "message"))
			el.attributes["to"] = to
			el.attributes["from"] = fro
			x = el.addElement(state)
			x.attributes["xmlns"] = globals.CHATSTATES
			self.pytrans.send(el)
Example #45
0
 def connectionMade(self):
     request = Element((None, 'register_download_server'))
     request['host'] = self.factory.host
     request['port'] = str(self.factory.port)
     for movie in movies:
         m = request.addElement('movie')
         m['id_movie'] = movie.id_movie
         m['title'] = movie.title
         m['size'] = str(movie.size)
     self.sendObject(request)
Example #46
0
 def sendNickname(self, tojid=None):
     if not tojid:
         tojid = self.contactList.session.jabberID
     if self.nickname:
         el = Element((None, "message"))
         el.attributes["to"] = tojid
         el.attributes["from"] = self.jid
         nick = el.addElement("nick")
         nick.attributes["xmlns"] = globals.NICK
         nick.addContent(self.nickname)
         self.contactList.session.pytrans.send(el)
Example #47
0
def formRegEntry(username, password):
	""" Returns a domish.Element representation of the data passed. This element will be written to the XDB spool file """
	reginfo = Element((None, "query"))
	reginfo.attributes["xmlns"] = "jabber:iq:register"
	
	userEl = reginfo.addElement("username")
	userEl.addContent(username)
	
	passEl = reginfo.addElement("password")
	passEl.addContent(password)

	return reginfo
Example #48
0
    def testAddObserverInDispatch(self):
        # Test for registration of events during dispatch
        d = EventDispatcher()
        msg = Element(("ns", "message"))
        pres = Element(("ns", "presence"))
        cb = CallbackTracker2(d)

        d.addObserver("/message", cb.call2)
        d.dispatch(msg)
        self.assertEquals(cb.called, 0)
        d.dispatch(pres)
        self.assertEquals(cb.called, 1)
Example #49
0
    def testDispatcherResult(self):
        d = EventDispatcher()
        msg = Element(("ns", "message"))
        pres = Element(("ns", "presence"))
        cb = CallbackTracker()

        d.addObserver("/presence", cb.call)
        result = d.dispatch(msg)
        self.assertEquals(False, result)

        result = d.dispatch(pres)
        self.assertEquals(True, result)
Example #50
0
def incoming_reply(q, bus, conn):
    chan, outbound, contact_name, self_handle_name = \
        setup_incoming_tests(q, bus, conn)

    moar = Element((ycs.MESSAGE_NS, 'message'))
    moar['ninety-nine-problems'] = 'but a sauvignon blanc aint one'
    moar['also'] = 'my mum said hi'
    trollface = moar.addElement('trollface', content='problem?')

    call_async(
        q, chan, 'Reply', {
            'ninety-nine-problems': 'but a sauvignon blanc aint one',
            'also': 'my mum said hi'
        }, moar.toXml())

    _, e = q.expect_many(EventPattern('dbus-return', method='Reply'),
                         EventPattern('stream-iq', connection=outbound))

    iq = e.stanza
    assertEquals('le-loldongs', iq['id'])
    assertEquals('result', iq['type'])
    assertEquals(self_handle_name, iq['from'])
    assertEquals(contact_name, iq['to'])
    assertEquals(1, len(iq.children))

    message = iq.children[0]

    assertEquals('message', message.name)
    assertEquals(ycs.MESSAGE_NS, message.uri)
    assertEquals('my mum said hi', message['also'])
    assertEquals('but a sauvignon blanc aint one',
                 message['ninety-nine-problems'])
    assertEquals('the.from.service', message['to-service'])
    assertEquals('the.to.service', message['from-service'])
    assertEquals(1, len(message.children))

    trollface = message.children[0]

    assertEquals('trollface', trollface.name)
    assertEquals(1, len(trollface.children))

    assertEquals('problem?', trollface.children[0])

    # check we can't call anything any more
    call_async(q, chan, 'Fail', ycs.ERROR_TYPE_CANCEL, 'lol', 'whut', 'pear')
    q.expect('dbus-error', method='Fail')

    call_async(q, chan, 'Reply', {'lol': 'whut'}, '')
    q.expect('dbus-error', method='Reply')

    call_async(q, chan, 'Request')
    q.expect('dbus-error', method='Request')
Example #51
0
 def joinChatRoom(self, room):
     presence = Element((None, 'presence'))
     presence['from'] = self.jid.userhost()
     jid = '%s@%s/%s' % (room, self.SERVICECONFIG.JABBER_CHAT_SERVICE,
                         self.SERVICECONFIG.JABBER_CHAT_NICK)
     presence['to'] = jid
     x = Element(('http://jabber.org/protocol/muc', 'x'))
     history = Element((None, 'history'))
     history['maxchars'] = '0'
     x.addChild(history)
     presence.addChild(x)
     log('sending join: %s' % presence.toXml())
     self.xmlstream.send(presence)
Example #52
0
    def testOrderedXPathDispatch(self):
        d = EventDispatcher()
        cb = OrderedCallbackTracker()
        d.addObserver("/message/body", cb.call2)
        d.addObserver("/message", cb.call3, -1)
        d.addObserver("/message/body", cb.call1, 1)

        msg = Element(("ns", "message"))
        msg.addElement("body")
        d.dispatch(msg)
        self.assertEquals(
            cb.callList, [cb.call1, cb.call2, cb.call3],
            "Calls out of order: %s" % repr([c.__name__ for c in cb.callList]))
Example #53
0
 def requestAuthorization(self, to):
     request = Element((None, 'iq'))
     request['type'] = 'set'
     request['id'] = 'auth-request:%s' % to
     query = Element((None, 'query'))
     query['xmlns'] = 'jabber:iq:roster'
     item = Element((None, 'item'))
     item['jid'] = to
     item['name'] = to.split('@')[0]
     query.addChild(item)
     request.addChild(query)
     log('sending auth request: %s' % request.toXml())
     self.xmlstream.send(request)
Example #54
0
    def testStuff(self):
        d = EventDispatcher()
        cb1 = CallbackTracker()
        cb2 = CallbackTracker()
        cb3 = CallbackTracker()

        d.addObserver("/message/body", cb1.call)
        d.addObserver("/message", cb1.call)
        d.addObserver("/presence", cb2.call)
        d.addObserver("//event/testevent", cb3.call)

        msg = Element(("ns", "message"))
        msg.addElement("body")

        pres = Element(("ns", "presence"))
        pres.addElement("presence")

        d.dispatch(msg)
        self.assertEquals(cb1.called, 2)
        self.assertEquals(cb1.obj, msg)
        self.assertEquals(cb2.called, 0)

        d.dispatch(pres)
        self.assertEquals(cb1.called, 2)
        self.assertEquals(cb2.called, 1)
        self.assertEquals(cb2.obj, pres)
        self.assertEquals(cb3.called, 0)

        d.dispatch(d, "//event/testevent")
        self.assertEquals(cb3.called, 1)
        self.assertEquals(cb3.obj, d)

        d.removeObserver("/presence", cb2.call)
        d.dispatch(pres)
        self.assertEquals(cb2.called, 1)
Example #55
0
 def sendMessage(self, to, body):
     """ Send a text message
     """
     message = Element((
         None,
         "message",
     ))
     message["id"] = getRandomId()
     message["from"] = self.xmlstream.factory.authenticator.jid.full()
     message["to"] = to.full()
     message["type"] = 'chat'
     message.addElement('body', content=body)
     self.xmlstream.send(message)
     return True
Example #56
0
	def sendRosterImport(self, jid, ptype, sub, name="", groups=[]):
		""" Sends a special presence packet. This will work with all clients, but clients that support roster-import will give a better user experience
		IMPORTANT - Only ever use this for contacts that have already been authorised on the legacy service """
		x = Element((None, "x"))
		x.attributes["xmlns"] = disco.SUBSYNC
		item = x.addElement("item")
		item.attributes["subscription"] = sub
		if name:
			item.attributes["name"] = unicode(name)
		for group in groups:
			g = item.addElement("group")
			g.addContent(group)
		
		self.sendPresence(to=self.jabberID, fro=jid, ptype=ptype, payload=[x])
Example #57
0
    def componentConnected(self, xmlstream):
        LogEvent(INFO)
        self.xmlstream = xmlstream
        self.xmlstream.addObserver("/iq", self.iq.onIq)
        self.xmlstream.addObserver("/presence", self.onPresence)
        self.xmlstream.addObserver("/message", self.onMessage)
        self.xmlstream.addObserver("/bind", self.onBind)
        self.xmlstream.addObserver("/route", self.onRouteMessage)
        self.xmlstream.addObserver(
            "/error[@xmlns='http://etherx.jabber.org/streams']",
            self.streamError)
        if config.useXCP and config.compjid:
            pres = Element((None, "presence"))
            pres.attributes["to"] = "presence@-internal"
            pres.attributes["from"] = config.compjid
            x = pres.addElement("x")
            x.attributes["xmlns"] = globals.COMPPRESENCE
            x.attributes["xmlns:config"] = globals.CONFIG
            x.attributes["config:version"] = "1"
            x.attributes["protocol-version"] = "1.0"
            x.attributes["config-ns"] = legacy.url + "/component"
            self.send(pres)
        if config.useComponentBinding:
            LogEvent(INFO, msg="Component binding to %r" % config.jid)
            bind = Element((None, "bind"))
            bind.attributes["name"] = config.jid
            self.send(bind)
        if config.useRouteWrap:
            self.routewrap = 1

        self.sendInvitations()
Example #58
0
	def saveLegacyList(self):
		contactList = self.session.legacycon.getContacts()
		if not contactList: return

		newXDB = Element((None, "query"))
		newXDB.attributes["xmlns"] = disco.IQROSTER
	
		for contact in contactList.contacts.values():
			item = newXDB.addElement("item")
			item.attributes["jid"] = contact.userHandle
			item.attributes["subscription"] = msnlist2jabsub(contact.lists) # Backwards compat
			item.attributes["lists"] = str(contact.lists)

		self.session.pytrans.xdb.set(self.jabberID, disco.IQROSTER, newXDB)
		LogEvent(INFO, self.jabberID, "Finished saving list.")
Example #59
0
	def sendTypingNotification(self, to, fro, typing):
		""" Sends the user the contact's current typing notification status """
		if self.typingUser:
			LogEvent(INFO, self.jabberID)
			el = Element((None, "message"))
			el.attributes["to"] = to
			el.attributes["from"] = fro
			x = el.addElement("x")
			x.attributes["xmlns"] = globals.XEVENT
			if typing:
				composing = x.addElement("composing") 
			id = x.addElement("id")
			if self.messageIDs.has_key(fro) and self.messageIDs[fro]:
				id.addContent(self.messageIDs[fro])
			self.pytrans.send(el)
Example #60
0
    def setSetting(self, jabberID, variable, value):
        """ Sets a user setting in the XDB. """
        prefs = self.request(jabberID, XDBNS_PREFERENCES)
        if prefs == None:
            prefs = Element((None, "query"))
            prefs.attributes["xmlns"] = XDBNS_PREFERENCES

        # Remove the existing element
        for child in prefs.elements():
            if child.name == variable:
                prefs.children.remove(child)

        newpref = prefs.addElement(variable)
        newpref.addContent(value)

        self.set(jabberID, XDBNS_PREFERENCES, prefs)