home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2011 October / maximum-cd-2011-10.iso / DiscContents / digsby_setup.exe / lib / pyxmpp / jabber / muccore.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-06-22  |  15.8 KB  |  497 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  3.  
  4. __revision__ = '$Id: muccore.py 714 2010-04-05 10:20:10Z jajcus $'
  5. __docformat__ = 'restructuredtext en'
  6. import libxml2
  7. from pyxmpp.utils import to_utf8, from_utf8
  8. from pyxmpp.xmlextra import common_doc, common_root, common_ns, get_node_ns_uri
  9. from pyxmpp.presence import Presence
  10. from pyxmpp.iq import Iq
  11. from pyxmpp.jid import JID
  12. from pyxmpp import xmlextra
  13. from pyxmpp.objects import StanzaPayloadWrapperObject
  14. from pyxmpp.xmlextra import xml_element_iter
  15. MUC_NS = 'http://jabber.org/protocol/muc'
  16. MUC_USER_NS = MUC_NS + '#user'
  17. MUC_ADMIN_NS = MUC_NS + '#admin'
  18. MUC_OWNER_NS = MUC_NS + '#owner'
  19. affiliations = ('admin', 'member', 'none', 'outcast', 'owner')
  20. roles = ('moderator', 'none', 'participant', 'visitor')
  21.  
  22. class MucXBase(StanzaPayloadWrapperObject):
  23.     element = 'x'
  24.     ns = None
  25.     
  26.     def __init__(self, xmlnode = None, copy = True, parent = None):
  27.         if self.ns == None:
  28.             raise RuntimeError, 'Pure virtual class called'
  29.         self.ns == None
  30.         self.xmlnode = None
  31.         self.borrowed = False
  32.         if isinstance(xmlnode, libxml2.xmlNode):
  33.             if copy:
  34.                 self.xmlnode = xmlnode.docCopyNode(common_doc, 1)
  35.                 common_root.addChild(self.xmlnode)
  36.             else:
  37.                 self.xmlnode = xmlnode
  38.                 self.borrowed = True
  39.             if copy:
  40.                 ns = xmlnode.ns()
  41.                 xmlextra.replace_ns(self.xmlnode, ns, common_ns)
  42.             
  43.         elif isinstance(xmlnode, MucXBase):
  44.             if not copy:
  45.                 raise TypeError, 'MucXBase may only be copied'
  46.             copy
  47.             self.xmlnode = xmlnode.xmlnode.docCopyNode(common_doc, 1)
  48.             common_root.addChild(self.xmlnode)
  49.         elif xmlnode is not None:
  50.             raise TypeError, 'Bad MucX constructor argument'
  51.         elif parent:
  52.             self.xmlnode = parent.newChild(None, self.element, None)
  53.             self.borrowed = True
  54.         else:
  55.             self.xmlnode = common_root.newChild(None, self.element, None)
  56.         ns = self.xmlnode.newNs(self.ns, None)
  57.         self.xmlnode.setNs(ns)
  58.  
  59.     
  60.     def __del__(self):
  61.         if self.xmlnode:
  62.             self.free()
  63.         
  64.  
  65.     
  66.     def free(self):
  67.         if not self.borrowed:
  68.             self.xmlnode.unlinkNode()
  69.             self.xmlnode.freeNode()
  70.         
  71.         self.xmlnode = None
  72.  
  73.     
  74.     def free_borrowed(self):
  75.         self.xmlnode = None
  76.  
  77.     
  78.     def xpath_eval(self, expr):
  79.         ctxt = common_doc.xpathNewContext()
  80.         ctxt.setContextNode(self.xmlnode)
  81.         ctxt.xpathRegisterNs('muc', self.ns.getContent())
  82.         ret = ctxt.xpathEval(to_utf8(expr))
  83.         ctxt.xpathFreeContext()
  84.         return ret
  85.  
  86.     
  87.     def serialize(self):
  88.         return self.xmlnode.serialize()
  89.  
  90.  
  91.  
  92. class MucX(MucXBase):
  93.     ns = MUC_NS
  94.     
  95.     def __init__(self, xmlnode = None, copy = True, parent = None):
  96.         MucXBase.__init__(self, xmlnode = xmlnode, copy = copy, parent = parent)
  97.  
  98.     
  99.     def set_history(self, parameters):
  100.         for child in xml_element_iter(self.xmlnode.children):
  101.             if get_node_ns_uri(child) == MUC_NS and child.name == 'history':
  102.                 child.unlinkNode()
  103.                 child.freeNode()
  104.                 break
  105.                 continue
  106.         
  107.         if parameters.maxchars and parameters.maxchars < 0:
  108.             raise ValueError, 'History parameter maxchars must be positive'
  109.         parameters.maxchars < 0
  110.         if parameters.maxstanzas and parameters.maxstanzas < 0:
  111.             raise ValueError, 'History parameter maxstanzas must be positive'
  112.         parameters.maxstanzas < 0
  113.         if parameters.maxseconds and parameters.maxseconds < 0:
  114.             raise ValueError, 'History parameter maxseconds must be positive'
  115.         parameters.maxseconds < 0
  116.         hnode = self.xmlnode.newChild(self.xmlnode.ns(), 'history', None)
  117.         if parameters.maxchars is not None:
  118.             hnode.setProp('maxchars', str(parameters.maxchars))
  119.         
  120.         if parameters.maxstanzas is not None:
  121.             hnode.setProp('maxstanzas', str(parameters.maxstanzas))
  122.         
  123.         if parameters.maxseconds is not None:
  124.             hnode.setProp('maxseconds', str(parameters.maxseconds))
  125.         
  126.         if parameters.since is not None:
  127.             hnode.setProp('since', parameters.since.strftime('%Y-%m-%dT%H:%M:%SZ'))
  128.         
  129.  
  130.     
  131.     def get_history(self):
  132.         for child in xml_element_iter(self.xmlnode.children):
  133.             if get_node_ns_uri(child) == MUC_NS and child.name == 'history':
  134.                 maxchars = from_utf8(child.prop('maxchars'))
  135.                 if maxchars is not None:
  136.                     maxchars = int(maxchars)
  137.                 
  138.                 maxstanzas = from_utf8(child.prop('maxstanzas'))
  139.                 if maxstanzas is not None:
  140.                     maxstanzas = int(maxstanzas)
  141.                 
  142.                 maxseconds = from_utf8(child.prop('maxseconds'))
  143.                 if maxseconds is not None:
  144.                     maxseconds = int(maxseconds)
  145.                 
  146.                 since = None
  147.                 return HistoryParameters(maxchars, maxstanzas, maxseconds, since)
  148.         
  149.  
  150.     
  151.     def set_password(self, password):
  152.         for child in xml_element_iter(self.xmlnode.children):
  153.             if get_node_ns_uri(child) == MUC_NS and child.name == 'password':
  154.                 child.unlinkNode()
  155.                 child.freeNode()
  156.                 break
  157.                 continue
  158.         
  159.         if password is not None:
  160.             self.xmlnode.newTextChild(self.xmlnode.ns(), 'password', to_utf8(password))
  161.         
  162.  
  163.     
  164.     def get_password(self):
  165.         for child in xml_element_iter(self.xmlnode.children):
  166.             if get_node_ns_uri(child) == MUC_NS and child.name == 'password':
  167.                 return from_utf8(child.getContent())
  168.         
  169.  
  170.  
  171.  
  172. class HistoryParameters(object):
  173.     
  174.     def __init__(self, maxchars = None, maxstanzas = None, maxseconds = None, since = None):
  175.         self.maxchars = maxchars
  176.         self.maxstanzas = maxstanzas
  177.         self.maxseconds = maxseconds
  178.         self.since = since
  179.  
  180.  
  181.  
  182. class MucItemBase(object):
  183.     
  184.     def __init__(self):
  185.         if self.__class__ is MucItemBase:
  186.             raise RuntimeError, 'Abstract class called'
  187.         self.__class__ is MucItemBase
  188.  
  189.  
  190.  
  191. class MucItem(MucItemBase):
  192.     
  193.     def __init__(self, xmlnode_or_affiliation, role = None, jid = None, nick = None, actor = None, reason = None):
  194.         (self.jid, self.nick, self.actor, self.affiliation, self.reason, self.role) = (None, None, None, None, None, None)
  195.         MucItemBase.__init__(self)
  196.         if isinstance(xmlnode_or_affiliation, libxml2.xmlNode):
  197.             self._MucItem__from_xmlnode(xmlnode_or_affiliation)
  198.         else:
  199.             self._MucItem__init(xmlnode_or_affiliation, role, jid, nick, actor, reason)
  200.  
  201.     
  202.     def __init(self, affiliation, role, jid = None, nick = None, actor = None, reason = None):
  203.         if not affiliation:
  204.             affiliation = None
  205.         elif affiliation not in affiliations:
  206.             raise ValueError, 'Bad affiliation'
  207.         
  208.         self.affiliation = affiliation
  209.         if not role:
  210.             role = None
  211.         elif role not in roles:
  212.             raise ValueError, 'Bad role'
  213.         
  214.         self.role = role
  215.         if jid:
  216.             self.jid = JID(jid)
  217.         else:
  218.             self.jid = None
  219.         if actor:
  220.             self.actor = JID(actor)
  221.         else:
  222.             self.actor = None
  223.         self.nick = nick
  224.         self.reason = reason
  225.  
  226.     
  227.     def __from_xmlnode(self, xmlnode):
  228.         actor = None
  229.         reason = None
  230.         n = xmlnode.children
  231.         while n:
  232.             ns = n.ns()
  233.             if ns and ns.getContent() != MUC_USER_NS:
  234.                 continue
  235.             
  236.             if n.name == 'actor':
  237.                 actor = n.getContent()
  238.             
  239.             if n.name == 'reason':
  240.                 reason = n.getContent()
  241.             
  242.             n = n.next
  243.         self._MucItem__init(from_utf8(xmlnode.prop('affiliation')), from_utf8(xmlnode.prop('role')), from_utf8(xmlnode.prop('jid')), from_utf8(xmlnode.prop('nick')), from_utf8(actor), from_utf8(reason))
  244.  
  245.     
  246.     def as_xml(self, parent):
  247.         n = parent.newChild(None, 'item', None)
  248.         if self.actor:
  249.             n.newTextChild(None, 'actor', to_utf8(self.actor))
  250.         
  251.         if self.reason:
  252.             n.newTextChild(None, 'reason', to_utf8(self.reason))
  253.         
  254.         n.setProp('affiliation', to_utf8(self.affiliation))
  255.         if self.role:
  256.             n.setProp('role', to_utf8(self.role))
  257.         
  258.         if self.jid:
  259.             n.setProp('jid', to_utf8(self.jid.as_unicode()))
  260.         
  261.         if self.nick:
  262.             n.setProp('nick', to_utf8(self.nick))
  263.         
  264.         return n
  265.  
  266.  
  267.  
  268. class MucStatus(MucItemBase):
  269.     
  270.     def __init__(self, xmlnode_or_code):
  271.         self.code = None
  272.         MucItemBase.__init__(self)
  273.         if isinstance(xmlnode_or_code, libxml2.xmlNode):
  274.             self._MucStatus__from_xmlnode(xmlnode_or_code)
  275.         else:
  276.             self._MucStatus__init(xmlnode_or_code)
  277.  
  278.     
  279.     def __init(self, code):
  280.         code = int(code)
  281.         if code < 0 or code > 999:
  282.             raise ValueError, 'Bad status code'
  283.         code > 999
  284.         self.code = code
  285.  
  286.     
  287.     def __from_xmlnode(self, xmlnode):
  288.         self.code = int(xmlnode.prop('code'))
  289.  
  290.     
  291.     def as_xml(self, parent):
  292.         n = parent.newChild(None, 'status', None)
  293.         n.setProp('code', '%03i' % (self.code,))
  294.         return n
  295.  
  296.  
  297.  
  298. class MucUserX(MucXBase):
  299.     ns = MUC_USER_NS
  300.     
  301.     def get_items(self):
  302.         if not self.xmlnode.children:
  303.             return []
  304.         ret = []
  305.         n = self.xmlnode.children
  306.         while n:
  307.             ns = n.ns()
  308.             if ns and ns.getContent() != self.ns:
  309.                 pass
  310.             elif n.name == 'item':
  311.                 ret.append(MucItem(n))
  312.             elif n.name == 'status':
  313.                 ret.append(MucStatus(n))
  314.             
  315.             n = n.next
  316.         return ret
  317.  
  318.     
  319.     def clear(self):
  320.         if not self.xmlnode.children:
  321.             return None
  322.         n = self.xmlnode.children
  323.         while n:
  324.             ns = n.ns()
  325.             if ns and ns.getContent() != MUC_USER_NS:
  326.                 pass
  327.             else:
  328.                 n.unlinkNode()
  329.                 n.freeNode()
  330.             n = n.next
  331.  
  332.     
  333.     def add_item(self, item):
  334.         if not isinstance(item, MucItemBase):
  335.             raise TypeError, 'Bad item type for muc#user'
  336.         isinstance(item, MucItemBase)
  337.         item.as_xml(self.xmlnode)
  338.  
  339.  
  340.  
  341. class MucOwnerX(MucXBase):
  342.     pass
  343.  
  344.  
  345. class MucAdminQuery(MucUserX):
  346.     ns = MUC_ADMIN_NS
  347.     element = 'query'
  348.  
  349.  
  350. class MucStanzaExt:
  351.     
  352.     def __init__(self):
  353.         if self.__class__ is MucStanzaExt:
  354.             raise RuntimeError, 'Abstract class called'
  355.         self.__class__ is MucStanzaExt
  356.         self.xmlnode = None
  357.         self.muc_child = None
  358.  
  359.     
  360.     def get_muc_child(self):
  361.         if self.muc_child:
  362.             return self.muc_child
  363.         if not self.xmlnode.children:
  364.             return None
  365.         n = self.xmlnode.children
  366.         while n:
  367.             ns = n.ns()
  368.             if not ns:
  369.                 n = n.next
  370.                 continue
  371.             
  372.             ns_uri = ns.getContent()
  373.             if (n.name, ns_uri) == ('x', MUC_NS):
  374.                 self.muc_child = MucX(n)
  375.                 return self.muc_child
  376.             if (n.name, ns_uri) == ('x', MUC_USER_NS):
  377.                 self.muc_child = MucUserX(n)
  378.                 return self.muc_child
  379.             if (n.name, ns_uri) == ('query', MUC_ADMIN_NS):
  380.                 self.muc_child = MucAdminQuery(n)
  381.                 return self.muc_child
  382.             if (n.name, ns_uri) == ('query', MUC_OWNER_NS):
  383.                 self.muc_child = MucOwnerX(n)
  384.                 return self.muc_child
  385.             n = n.next
  386.             continue
  387.             (n.name, ns_uri) == ('query', MUC_OWNER_NS)
  388.  
  389.     
  390.     def clear_muc_child(self):
  391.         if self.muc_child:
  392.             self.muc_child.free_borrowed()
  393.             self.muc_child = None
  394.         
  395.         if not self.xmlnode.children:
  396.             return None
  397.         n = self.xmlnode.children
  398.         while n:
  399.             if n.name not in ('x', 'query'):
  400.                 n = n.next
  401.                 continue
  402.             
  403.             ns = n.ns()
  404.             if not ns:
  405.                 n = n.next
  406.                 continue
  407.             
  408.             ns_uri = ns.getContent()
  409.             if ns_uri in (MUC_NS, MUC_USER_NS, MUC_ADMIN_NS, MUC_OWNER_NS):
  410.                 n.unlinkNode()
  411.                 n.freeNode()
  412.             
  413.             n = n.next
  414.  
  415.     
  416.     def make_muc_userinfo(self):
  417.         self.clear_muc_child()
  418.         self.muc_child = MucUserX(parent = self.xmlnode)
  419.         return self.muc_child
  420.  
  421.     
  422.     def make_muc_admin_quey(self):
  423.         self.clear_muc_child()
  424.         self.muc_child = MucAdminQuery(parent = self.xmlnode)
  425.         return self.muc_child
  426.  
  427.     
  428.     def muc_free(self):
  429.         if self.muc_child:
  430.             self.muc_child.free_borrowed()
  431.         
  432.  
  433.  
  434.  
  435. class MucPresence(Presence, MucStanzaExt):
  436.     
  437.     def __init__(self, xmlnode = None, from_jid = None, to_jid = None, stanza_type = None, stanza_id = None, show = None, status = None, priority = 0, error = None, error_cond = None):
  438.         MucStanzaExt.__init__(self)
  439.         Presence.__init__(self, xmlnode, from_jid = from_jid, to_jid = to_jid, stanza_type = stanza_type, stanza_id = stanza_id, show = show, status = status, priority = priority, error = error, error_cond = error_cond)
  440.  
  441.     
  442.     def copy(self):
  443.         return MucPresence(self)
  444.  
  445.     
  446.     def make_join_request(self, password = None, history_maxchars = None, history_maxstanzas = None, history_seconds = None, history_since = None):
  447.         self.clear_muc_child()
  448.         self.muc_child = MucX(parent = self.xmlnode)
  449.         if history_maxchars is not None and history_maxstanzas is not None and history_seconds is not None or history_since is not None:
  450.             history = HistoryParameters(history_maxchars, history_maxstanzas, history_seconds, history_since)
  451.             self.muc_child.set_history(history)
  452.         
  453.         if password is not None:
  454.             self.muc_child.set_password(password)
  455.         
  456.  
  457.     
  458.     def get_join_info(self):
  459.         x = self.get_muc_child()
  460.         if not x:
  461.             return None
  462.         if not isinstance(x, MucX):
  463.             return None
  464.         return x
  465.  
  466.     
  467.     def free(self):
  468.         self.muc_free()
  469.         Presence.free(self)
  470.  
  471.  
  472.  
  473. class MucIq(Iq, MucStanzaExt):
  474.     
  475.     def __init__(self, xmlnode = None, from_jid = None, to_jid = None, stanza_type = None, stanza_id = None, error = None, error_cond = None):
  476.         MucStanzaExt.__init__(self)
  477.         Iq.__init__(self, xmlnode, from_jid = from_jid, to_jid = to_jid, stanza_type = stanza_type, stanza_id = stanza_id, error = error, error_cond = error_cond)
  478.  
  479.     
  480.     def copy(self):
  481.         return MucIq(self)
  482.  
  483.     
  484.     def make_kick_request(self, nick, reason):
  485.         self.clear_muc_child()
  486.         self.muc_child = MucAdminQuery(parent = self.xmlnode)
  487.         item = MucItem('none', 'none', nick = nick, reason = reason)
  488.         self.muc_child.add_item(item)
  489.         return self.muc_child
  490.  
  491.     
  492.     def free(self):
  493.         self.muc_free()
  494.         Iq.free(self)
  495.  
  496.  
  497.