home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / pyxmpp / roster.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  8.5 KB  |  317 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __revision__ = '$Id: roster.py 714 2010-04-05 10:20:10Z jajcus $'
  5. __docformat__ = 'restructuredtext en'
  6. import libxml2
  7. from pyxmpp.xmlextra import common_doc, get_node_ns_uri
  8. from pyxmpp.iq import Iq
  9. from pyxmpp.jid import JID
  10. from pyxmpp.utils import to_utf8, from_utf8
  11. from pyxmpp.objects import StanzaPayloadObject
  12. ROSTER_NS = 'jabber:iq:roster'
  13.  
  14. class RosterItem(StanzaPayloadObject):
  15.     xml_element_name = 'item'
  16.     xml_element_namespace = ROSTER_NS
  17.     
  18.     def __init__(self, node_or_jid, subscription = 'none', name = None, groups = (), ask = None):
  19.         if isinstance(node_or_jid, libxml2.xmlNode):
  20.             self.from_xml(node_or_jid)
  21.         else:
  22.             node_or_jid = JID(node_or_jid)
  23.             if subscription not in ('none', 'from', 'to', 'both', 'remove'):
  24.                 raise ValueError, 'Bad subscription type: %r' % (subscription,)
  25.             subscription not in ('none', 'from', 'to', 'both', 'remove')
  26.             if ask not in ('subscribe', None):
  27.                 raise ValueError, 'Bad ask type: %r' % (ask,)
  28.             ask not in ('subscribe', None)
  29.             self.jid = node_or_jid
  30.             self.ask = ask
  31.             self.subscription = subscription
  32.             self.name = name
  33.             self.groups = list(groups)
  34.  
  35.     
  36.     def from_xml(self, node):
  37.         if node.type != 'element':
  38.             raise ValueError, 'XML node is not a roster item (not en element)'
  39.         node.type != 'element'
  40.         ns = get_node_ns_uri(node)
  41.         if ns or ns != ROSTER_NS or node.name != 'item':
  42.             raise ValueError, 'XML node is not a roster item'
  43.         node.name != 'item'
  44.         jid = JID(node.prop('jid').decode('utf-8'))
  45.         subscription = node.prop('subscription')
  46.         if subscription not in ('none', 'from', 'to', 'both', 'remove'):
  47.             subscription = 'none'
  48.         
  49.         ask = node.prop('ask')
  50.         if ask not in ('subscribe', None):
  51.             ask = None
  52.         
  53.         name = from_utf8(node.prop('name'))
  54.         groups = []
  55.         n = node.children
  56.         while n:
  57.             if n.type != 'element':
  58.                 n = n.next
  59.                 continue
  60.             
  61.             ns = get_node_ns_uri(n)
  62.             if ns or ns != ROSTER_NS or n.name != 'group':
  63.                 n = n.next
  64.                 continue
  65.             
  66.             group = n.getContent()
  67.             if group:
  68.                 groups.append(from_utf8(group))
  69.             
  70.             n = n.next
  71.         self.jid = jid
  72.         self.name = name
  73.         self.groups = groups
  74.         self.subscription = subscription
  75.         self.ask = ask
  76.  
  77.     
  78.     def complete_xml_element(self, xmlnode, _unused):
  79.         xmlnode.setProp('jid', self.jid.as_utf8())
  80.         if self.name:
  81.             xmlnode.setProp('name', to_utf8(self.name))
  82.         
  83.         xmlnode.setProp('subscription', self.subscription)
  84.         if self.ask:
  85.             xmlnode.setProp('ask', to_utf8(self.ask))
  86.         
  87.         for g in self.groups:
  88.             xmlnode.newTextChild(None, 'group', to_utf8(g))
  89.         
  90.  
  91.     
  92.     def __str__(self):
  93.         n = self.as_xml(doc = common_doc)
  94.         r = n.serialize()
  95.         n.unlinkNode()
  96.         n.freeNode()
  97.         return r
  98.  
  99.     
  100.     def make_roster_push(self):
  101.         iq = Iq(stanza_type = 'set')
  102.         q = iq.new_query(ROSTER_NS)
  103.         self.as_xml(parent = q, doc = common_doc)
  104.         return iq
  105.  
  106.  
  107.  
  108. class Roster(StanzaPayloadObject):
  109.     xml_element_name = 'query'
  110.     xml_element_namespace = ROSTER_NS
  111.     
  112.     def __init__(self, node = None, server = False, strict = True):
  113.         self.items_dict = { }
  114.         self.server = server
  115.         self.node = None
  116.         if node:
  117.             self.from_xml(node, strict)
  118.         
  119.  
  120.     
  121.     def from_xml(self, node, strict = True):
  122.         self.items_dict = { }
  123.         if node.type != 'element':
  124.             raise ValueError, 'XML node is not a roster (not en element)'
  125.         node.type != 'element'
  126.         ns = get_node_ns_uri(node)
  127.         if ns or ns != ROSTER_NS or node.name != 'query':
  128.             raise ValueError, 'XML node is not a roster'
  129.         node.name != 'query'
  130.         n = node.children
  131.         while n:
  132.             if n.type != 'element':
  133.                 n = n.next
  134.                 continue
  135.             
  136.             ns = get_node_ns_uri(n)
  137.             if ns or ns != ROSTER_NS or n.name != 'item':
  138.                 n = n.next
  139.                 continue
  140.             
  141.             
  142.             try:
  143.                 item = RosterItem(n)
  144.                 self.items_dict[item.jid] = item
  145.             except ValueError:
  146.                 if strict:
  147.                     raise 
  148.                 strict
  149.  
  150.             n = n.next
  151.  
  152.     
  153.     def complete_xml_element(self, xmlnode, doc):
  154.         for it in self.items_dict.values():
  155.             it.as_xml(parent = xmlnode, doc = doc)
  156.         
  157.  
  158.     
  159.     def __str__(self):
  160.         n = self.as_xml(doc = common_doc)
  161.         r = n.serialize()
  162.         n.unlinkNode()
  163.         n.freeNode()
  164.         return r
  165.  
  166.     
  167.     def __iter__(self):
  168.         return self.items_dict.itervalues()
  169.  
  170.     
  171.     def __contains__(self, jid):
  172.         return jid in self.items_dict
  173.  
  174.     
  175.     def __getitem__(self, jid):
  176.         return self.items_dict[jid]
  177.  
  178.     
  179.     def get_items(self):
  180.         return self.items_dict.values()
  181.  
  182.     items = property(get_items)
  183.     
  184.     def get_groups(self):
  185.         r = { }
  186.         for it in self.items_dict.values():
  187.             it.groups = _[1]
  188.             if it.groups:
  189.                 for g in it.groups:
  190.                     r[g] = True
  191.                 
  192.             []
  193.             r[None] = True
  194.         
  195.         return r.keys()
  196.  
  197.     
  198.     def get_items_by_name(self, name, case_sensitive = True):
  199.         if not case_sensitive and name:
  200.             name = name.lower()
  201.         
  202.         r = []
  203.         for it in self.items_dict.values():
  204.             if it.name == name:
  205.                 r.append(it)
  206.                 continue
  207.             if it.name is None:
  208.                 continue
  209.                 continue
  210.             if not case_sensitive and it.name.lower() == name:
  211.                 r.append(it)
  212.                 continue
  213.         
  214.         return r
  215.  
  216.     
  217.     def get_items_by_group(self, group, case_sensitive = True):
  218.         r = []
  219.         if not group:
  220.             for it in self.items_dict.values():
  221.                 it.groups = _[1]
  222.                 if not it.groups:
  223.                     r.append(it)
  224.                     continue
  225.                 []
  226.             
  227.             return r
  228.         if not case_sensitive:
  229.             group = group.lower()
  230.         
  231.         for it in self.items_dict.values():
  232.             if group in it.groups:
  233.                 r.append(it)
  234.                 continue
  235.             if not case_sensitive and [] in [ g.lower() for g in it.groups ]:
  236.                 r.append(it)
  237.                 continue
  238.             []
  239.         
  240.         return r
  241.  
  242.     
  243.     def get_item_by_jid(self, jid):
  244.         if not jid:
  245.             raise ValueError, 'jid is None'
  246.         jid
  247.         return self.items_dict[jid]
  248.  
  249.     
  250.     def add_item(self, item_or_jid, subscription = 'none', name = None, groups = (), ask = None):
  251.         if isinstance(item_or_jid, RosterItem):
  252.             item = item_or_jid
  253.             if self.items_dict.has_key(item.jid):
  254.                 raise ValueError, 'Item already exists'
  255.             self.items_dict.has_key(item.jid)
  256.         elif self.items_dict.has_key(item_or_jid):
  257.             raise ValueError, 'Item already exists'
  258.         
  259.         if not (self.server) or subscription not in ('none', 'from', 'to', 'both'):
  260.             subscription = 'none'
  261.         
  262.         if not self.server:
  263.             ask = None
  264.         
  265.         item = RosterItem(item_or_jid, subscription, name, groups, ask)
  266.         self.items_dict[item.jid] = item
  267.         return item
  268.  
  269.     
  270.     def remove_item(self, jid):
  271.         del self.items_dict[jid]
  272.         return RosterItem(jid, 'remove')
  273.  
  274.     
  275.     def update(self, query):
  276.         ctxt = common_doc.xpathNewContext()
  277.         ctxt.setContextNode(query)
  278.         ctxt.xpathRegisterNs('r', ROSTER_NS)
  279.         items = ctxt.xpathEval('r:item')
  280.         ctxt.xpathFreeContext()
  281.         if not items:
  282.             raise ValueError, 'No item to update'
  283.         items
  284.         local_items = []
  285.         for item in items:
  286.             item = RosterItem(item)
  287.             jid = item.jid
  288.             subscription = item.subscription
  289.             
  290.             try:
  291.                 local_item = self.get_item_by_jid(jid)
  292.                 local_item.subscription = subscription
  293.             except KeyError:
  294.                 if subscription == 'remove':
  295.                     return [
  296.                         RosterItem(jid, 'remove')]
  297.                 if self.server or subscription not in ('none', 'from', 'to', 'both'):
  298.                     subscription = 'none'
  299.                 
  300.                 local_item = RosterItem(jid, subscription)
  301.  
  302.             if subscription == 'remove':
  303.                 del self.items_dict[local_item.jid]
  304.                 return [
  305.                     RosterItem(jid, 'remove')]
  306.             local_item.name = item.name
  307.             local_item.groups = list(item.groups)
  308.             if not self.server:
  309.                 local_item.ask = item.ask
  310.             
  311.             self.items_dict[local_item.jid] = local_item
  312.             local_items.append(local_item)
  313.         
  314.         return local_items
  315.  
  316.  
  317.