home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / pyxmpp / jabber / muccore.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  15.8 KB  |  510 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __revision__ = '$Id: muccore.py 648 2006-08-26 20:09:37Z 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.         
  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.             
  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.         
  110.         if parameters.maxstanzas and parameters.maxstanzas < 0:
  111.             raise ValueError, 'History parameter maxstanzas must be positive'
  112.         
  113.         if parameters.maxseconds and parameters.maxseconds < 0:
  114.             raise ValueError, 'History parameter maxseconds must be positive'
  115.         
  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.                 continue
  149.         
  150.  
  151.     
  152.     def set_password(self, password):
  153.         for child in xml_element_iter(self.xmlnode.children):
  154.             if get_node_ns_uri(child) == MUC_NS and child.name == 'password':
  155.                 child.unlinkNode()
  156.                 child.freeNode()
  157.                 break
  158.                 continue
  159.         
  160.         if password is not None:
  161.             self.xmlnode.newTextChild(self.xmlnode.ns(), 'password', to_utf8(password))
  162.         
  163.  
  164.     
  165.     def get_password(self):
  166.         for child in xml_element_iter(self.xmlnode.children):
  167.             if get_node_ns_uri(child) == MUC_NS and child.name == 'password':
  168.                 return from_utf8(child.getContent())
  169.                 continue
  170.         
  171.  
  172.  
  173.  
  174. class HistoryParameters(object):
  175.     
  176.     def __init__(self, maxchars = None, maxstanzas = None, maxseconds = None, since = None):
  177.         self.maxchars = maxchars
  178.         self.maxstanzas = maxstanzas
  179.         self.maxseconds = maxseconds
  180.         self.since = since
  181.  
  182.  
  183.  
  184. class MucItemBase(object):
  185.     
  186.     def __init__(self):
  187.         if self.__class__ is MucItemBase:
  188.             raise RuntimeError, 'Abstract class called'
  189.         
  190.  
  191.  
  192.  
  193. class MucItem(MucItemBase):
  194.     
  195.     def __init__(self, xmlnode_or_affiliation, role = None, jid = None, nick = None, actor = None, reason = None):
  196.         (self.jid, self.nick, self.actor, self.affiliation, self.reason, self.role) = (None, None, None, None, None, None)
  197.         MucItemBase.__init__(self)
  198.         if isinstance(xmlnode_or_affiliation, libxml2.xmlNode):
  199.             self._MucItem__from_xmlnode(xmlnode_or_affiliation)
  200.         else:
  201.             self._MucItem__init(xmlnode_or_affiliation, role, jid, nick, actor, reason)
  202.  
  203.     
  204.     def __init(self, affiliation, role, jid = None, nick = None, actor = None, reason = None):
  205.         if not affiliation:
  206.             affiliation = None
  207.         elif affiliation not in affiliations:
  208.             raise ValueError, 'Bad affiliation'
  209.         
  210.         self.affiliation = affiliation
  211.         if not role:
  212.             role = None
  213.         elif role not in roles:
  214.             raise ValueError, 'Bad role'
  215.         
  216.         self.role = role
  217.         if jid:
  218.             self.jid = JID(jid)
  219.         else:
  220.             self.jid = None
  221.         if actor:
  222.             self.actor = JID(actor)
  223.         else:
  224.             self.actor = None
  225.         self.nick = nick
  226.         self.reason = reason
  227.  
  228.     
  229.     def __from_xmlnode(self, xmlnode):
  230.         actor = None
  231.         reason = None
  232.         n = xmlnode.children
  233.         while n:
  234.             ns = n.ns()
  235.             if ns and ns.getContent() != MUC_USER_NS:
  236.                 continue
  237.             
  238.             if n.name == 'actor':
  239.                 actor = n.getContent()
  240.             
  241.             if n.name == 'reason':
  242.                 reason = n.getContent()
  243.             
  244.             n = n.next
  245.         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))
  246.  
  247.     
  248.     def as_xml(self, parent):
  249.         n = parent.newChild(None, 'item', None)
  250.         if self.actor:
  251.             n.newTextChild(None, 'actor', to_utf8(self.actor))
  252.         
  253.         if self.reason:
  254.             n.newTextChild(None, 'reason', to_utf8(self.reason))
  255.         
  256.         n.setProp('affiliation', to_utf8(self.affiliation))
  257.         n.setProp('role', to_utf8(self.role))
  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.         
  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.         
  305.         ret = []
  306.         n = self.xmlnode.children
  307.         while n:
  308.             ns = n.ns()
  309.             if ns and ns.getContent() != self.ns:
  310.                 pass
  311.             elif n.name == 'item':
  312.                 ret.append(MucItem(n))
  313.             elif n.name == 'status':
  314.                 ret.append(MucStatus(n))
  315.             
  316.             n = n.next
  317.         return ret
  318.  
  319.     
  320.     def clear(self):
  321.         if not self.xmlnode.children:
  322.             return None
  323.         
  324.         n = self.xmlnode.children
  325.         while n:
  326.             ns = n.ns()
  327.             if ns and ns.getContent() != MUC_USER_NS:
  328.                 pass
  329.             else:
  330.                 n.unlinkNode()
  331.                 n.freeNode()
  332.             n = n.next
  333.  
  334.     
  335.     def add_item(self, item):
  336.         if not isinstance(item, MucItemBase):
  337.             raise TypeError, 'Bad item type for muc#user'
  338.         
  339.         item.as_xml(self.xmlnode)
  340.  
  341.  
  342.  
  343. class MucOwnerX(MucXBase):
  344.     pass
  345.  
  346.  
  347. class MucAdminQuery(MucUserX):
  348.     ns = MUC_ADMIN_NS
  349.     element = 'query'
  350.  
  351.  
  352. class MucStanzaExt:
  353.     
  354.     def __init__(self):
  355.         if self.__class__ is MucStanzaExt:
  356.             raise RuntimeError, 'Abstract class called'
  357.         
  358.         self.xmlnode = None
  359.         self.muc_child = None
  360.  
  361.     
  362.     def get_muc_child(self):
  363.         if self.muc_child:
  364.             return self.muc_child
  365.         
  366.         if not self.xmlnode.children:
  367.             return None
  368.         
  369.         n = self.xmlnode.children
  370.         while n:
  371.             if n.name not in ('x', 'query'):
  372.                 n = n.next
  373.                 continue
  374.             
  375.             ns = n.ns()
  376.             if not ns:
  377.                 n = n.next
  378.                 continue
  379.             
  380.             ns_uri = ns.getContent()
  381.             if (n.name, ns_uri) == ('x', MUC_NS):
  382.                 self.muc_child = MucX(n)
  383.                 return self.muc_child
  384.             
  385.             if (n.name, ns_uri) == ('x', MUC_USER_NS):
  386.                 self.muc_child = MucUserX(n)
  387.                 return self.muc_child
  388.             
  389.             if (n.name, ns_uri) == ('query', MUC_ADMIN_NS):
  390.                 self.muc_child = MucAdminQuery(n)
  391.                 return self.muc_child
  392.             
  393.             if (n.name, ns_uri) == ('query', MUC_OWNER_NS):
  394.                 self.muc_child = MucOwnerX(n)
  395.                 return self.muc_child
  396.             
  397.             n = n.next
  398.  
  399.     
  400.     def clear_muc_child(self):
  401.         if self.muc_child:
  402.             self.muc_child.free_borrowed()
  403.             self.muc_child = None
  404.         
  405.         if not self.xmlnode.children:
  406.             return None
  407.         
  408.         n = self.xmlnode.children
  409.         while n:
  410.             if n.name not in ('x', 'query'):
  411.                 n = n.next
  412.                 continue
  413.             
  414.             ns = n.ns()
  415.             if not ns:
  416.                 n = n.next
  417.                 continue
  418.             
  419.             ns_uri = ns.getContent()
  420.             if ns_uri in (MUC_NS, MUC_USER_NS, MUC_ADMIN_NS, MUC_OWNER_NS):
  421.                 n.unlinkNode()
  422.                 n.freeNode()
  423.             
  424.             n = n.next
  425.  
  426.     
  427.     def make_muc_userinfo(self):
  428.         self.clear_muc_child()
  429.         self.muc_child = MucUserX(parent = self.xmlnode)
  430.         return self.muc_child
  431.  
  432.     
  433.     def make_muc_admin_quey(self):
  434.         self.clear_muc_child()
  435.         self.muc_child = MucAdminQuery(parent = self.xmlnode)
  436.         return self.muc_child
  437.  
  438.     
  439.     def muc_free(self):
  440.         if self.muc_child:
  441.             self.muc_child.free_borrowed()
  442.         
  443.  
  444.  
  445.  
  446. class MucPresence(Presence, MucStanzaExt):
  447.     
  448.     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):
  449.         MucStanzaExt.__init__(self)
  450.         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)
  451.  
  452.     
  453.     def copy(self):
  454.         return MucPresence(self)
  455.  
  456.     
  457.     def make_join_request(self, password = None, history_maxchars = None, history_maxstanzas = None, history_seconds = None, history_since = None):
  458.         self.clear_muc_child()
  459.         self.muc_child = MucX(parent = self.xmlnode)
  460.         if history_maxchars is not None and history_maxstanzas is not None and history_seconds is not None or history_since is not None:
  461.             history = HistoryParameters(history_maxchars, history_maxstanzas, history_seconds, history_since)
  462.             self.muc_child.set_history(history)
  463.         
  464.         if password is not None:
  465.             self.muc_child.set_password(password)
  466.         
  467.  
  468.     
  469.     def get_join_info(self):
  470.         x = self.get_muc_child()
  471.         if not x:
  472.             return None
  473.         
  474.         if not isinstance(x, MucX):
  475.             return None
  476.         
  477.         return x
  478.  
  479.     
  480.     def free(self):
  481.         self.muc_free()
  482.         Presence.free(self)
  483.  
  484.  
  485.  
  486. class MucIq(Iq, MucStanzaExt):
  487.     
  488.     def __init__(self, xmlnode = None, from_jid = None, to_jid = None, stanza_type = None, stanza_id = None, error = None, error_cond = None):
  489.         MucStanzaExt.__init__(self)
  490.         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)
  491.  
  492.     
  493.     def copy(self):
  494.         return MucIq(self)
  495.  
  496.     
  497.     def make_kick_request(self, nick, reason):
  498.         self.clear_muc_child()
  499.         self.muc_child = MucAdminQuery(parent = self.xmlnode)
  500.         item = MucItem('none', 'none', nick = nick, reason = reason)
  501.         self.muc_child.add_item(item)
  502.         return self.muc_child
  503.  
  504.     
  505.     def free(self):
  506.         self.muc_free()
  507.         Iq.free(self)
  508.  
  509.  
  510.