home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2009 June / maximum-cd-2009-06.iso / DiscContents / digsby_setup.exe / lib / oscar / ssi / SSIManager.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2009-02-26  |  18.3 KB  |  490 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from __future__ import with_statement
  5. from contextlib import contextmanager
  6. import oscar.snac as snac
  7. import oscar
  8. import common
  9. import struct
  10. from oscar.ssi import item, OscarSSIs, SSIException, ssi_err_types
  11. from util import gen_sequence, lookup_table, callsback
  12. from oscar.ssi.SSIItem import tuple_key
  13. from logging import getLogger
  14. log = getLogger('oscar.ssis')
  15. property_tlv_types = lookup_table(alias = 305, email = 311, SMSnum = 314, comment = 316)
  16.  
  17. def _lowerstrip(s):
  18.     return s.lower().replace(' ', '')
  19.  
  20.  
  21. class SSIManager(object):
  22.     
  23.     def __init__(self, protocol):
  24.         self.o = protocol
  25.         self.ssis = OscarSSIs(self)
  26.         self.ssi_edits_out = 0
  27.         self.generated_ssi_ids = []
  28.  
  29.     
  30.     def add_modify(self, new_ssi):
  31.         yield None
  32.         me = None
  33.         self.ssi_edit().__enter__()
  34.         
  35.         try:
  36.             if new_ssi in self.ssis:
  37.                 self._modify_ssi(new_ssi, me())
  38.             else:
  39.                 self._add_ssi(new_ssi, me())
  40.         finally:
  41.             pass
  42.  
  43.         yield None
  44.         errors = self.ssi_edit()
  45.  
  46.     add_modify = gen_sequence(add_modify)
  47.     
  48.     def new_ssi_item_id(self, group):
  49.         newid = 1
  50.         while (group, newid) in self.ssis or (group, newid) in self.generated_ssi_ids:
  51.             newid += 1
  52.         self.generated_ssi_ids += [
  53.             (group, newid)]
  54.         return newid
  55.  
  56.     
  57.     def new_ssi_group_id(self):
  58.         newid = 1
  59.         while (newid, 0) in self.ssis or (newid, 0) in self.generated_ssi_ids:
  60.             newid += 1
  61.         self.generated_ssi_ids += [
  62.             (newid, 0)]
  63.         return newid
  64.  
  65.     
  66.     def get_ssis_in_group(self, group_id, with_group = False):
  67.         pass
  68.  
  69.     
  70.     def get_ssis_by_type(self, type):
  71.         return _[1]
  72.  
  73.     
  74.     def _ssi_action(self, action, new_ssis, parent):
  75.         yield None
  76.         me = None
  77.         self.ssi_edit().__enter__()
  78.         
  79.         try:
  80.             if isinstance(new_ssis, item):
  81.                 new_ssis = [
  82.                     new_ssis]
  83.             
  84.             self.o.send_snac(19, action, ''.join((lambda .0: for s in .0:
  85. s.to_bytes())(new_ssis)), req = True, cb = me.send)
  86.         finally:
  87.             pass
  88.  
  89.         yield None
  90.         self.ssi_edit()(parent.send(self.o.gen_incoming))
  91.  
  92.     _ssi_action = gen_sequence(_ssi_action)
  93.     
  94.     def _ssi_double_action(self, action1, new_ssis1, action2, new_ssis2, parent):
  95.         yield None
  96.         me = None
  97.         self.ssi_edit().__enter__()
  98.         
  99.         try:
  100.             if isinstance(new_ssis1, item):
  101.                 new_ssis1 = [
  102.                     new_ssis1]
  103.             
  104.             if isinstance(new_ssis2, item):
  105.                 new_ssis2 = [
  106.                     new_ssis2]
  107.             
  108.             self.o.send_snac(19, action1, ''.join((lambda .0: for s in .0:
  109. s.to_bytes())(new_ssis1)), 5, True, me.send, action1)
  110.             self.o.send_snac(19, action2, ''.join((lambda .0: for s in .0:
  111. s.to_bytes())(new_ssis2)), 5, True, me.send, action2)
  112.         finally:
  113.             pass
  114.  
  115.         yield None
  116.         (sock1, snac1, ret_action1) = self.ssi_edit()
  117.         yield None
  118.         (sock2, snac2, ret_action2) = None
  119.         incoming1 = self.o.gen_incoming((sock1, snac1))
  120.         incoming2 = self.o.gen_incoming((sock2, snac2))
  121.         parent.send((incoming1, ret_action1, incoming2, ret_action2))
  122.  
  123.     _ssi_double_action = gen_sequence(_ssi_double_action)
  124.     
  125.     def _add_ssi(self, *a, **k):
  126.         self._ssi_action(8, *a, **k)
  127.  
  128.     
  129.     def _modify_ssi(self, *a, **k):
  130.         self._ssi_action(9, *a, **k)
  131.  
  132.     
  133.     def _remove_ssi(self, *a, **k):
  134.         self._ssi_action(10, *a, **k)
  135.  
  136.     
  137.     def add_new_ssi(self, name, group_protocol_object = None, position = 0, type_ = None, authorization = False, callback = None):
  138.         yield None
  139.         me = None
  140.         if not isinstance(name, str):
  141.             name = name.encode('utf-8')
  142.         
  143.         if group_protocol_object is not None:
  144.             group_protocol_object = tuple_key(group_protocol_object)
  145.             group_id = group_protocol_object[0]
  146.             item_id = self.new_ssi_item_id(group_protocol_object[0])
  147.             if type_ is None:
  148.                 type_ = 0
  149.             
  150.         else:
  151.             group_id = self.new_ssi_group_id()
  152.             item_id = 0
  153.             if type_ is None:
  154.                 type_ = 1
  155.             
  156.         new_ssi = item(name, group_id, item_id, type_)
  157.         if group_protocol_object is not None and authorization:
  158.             new_ssi.tlvs[102] = ''
  159.         
  160.         self.ssi_edit().__enter__()
  161.         
  162.         try:
  163.             yield self._add_ssi(new_ssi, me())
  164.             errors = self.ssi_edit()
  165.             if not errors[0]:
  166.                 self.ssis[new_ssi] = new_ssi
  167.                 if not group_protocol_object:
  168.                     pass
  169.                 ids = (0, 0)
  170.                 id_to_add = None if group_protocol_object else new_ssi.group_id
  171.                 self._add_to_group(ids, id_to_add, position)
  172.             else:
  173.                 callback.error()
  174.                 if errors[0] != 14:
  175.                     raise ','.join([] % ([]([ ssi_err_types[err] for err in errors ]), new_ssi))
  176.                 
  177.                 try:
  178.                     log.info(','.join((lambda .0: for g in .0:
  179. g.name)(self.ssis.root_group)))
  180.                 except:
  181.                     '%s: Error adding SSI %r to server list'
  182.                     SSIException
  183.                     log.error('error repr-ing groups')
  184.  
  185.                 self.ssis.root_group.notify()
  186.                 callback.success(new_ssi)
  187.                 return None
  188.  
  189.  
  190.     add_new_ssi = gen_sequence(callsback(add_new_ssi))
  191.     
  192.     def add_privacy_record(self, buddy, type_, callback = None):
  193.         yield None
  194.         me = None
  195.         name = common.get_bname(buddy)
  196.         self.ssi_edit().__enter__()
  197.         
  198.         try:
  199.             if not (self.find,)((lambda s: _lowerstrip(s.name) == _lowerstrip(name)), type = type_):
  200.                 log.critical('adding ' + name + ' to your privacy list')
  201.                 buddy_ssi = item(name, 0, self.new_ssi_item_id(0), type_)
  202.                 yield self._add_ssi(buddy_ssi, me())
  203.                 buddy_errs = self.ssi_edit()
  204.                 log.critical('ACK PRIVACY MOD!' + name)
  205.                 if not buddy_errs[0]:
  206.                     self.ssis[buddy_ssi] = buddy_ssi
  207.                 else:
  208.                     callback.error()
  209.                     raise ','.join([] + []([ ssi_err_types[err] for err in buddy_errs ]))
  210.             else:
  211.                 callback.error()
  212.                 raise SSIException('Buddy already in that privacy list.')
  213.         finally:
  214.             pass
  215.  
  216.         callback.success()
  217.         self.ssis.root_group.notify()
  218.  
  219.     add_privacy_record = gen_sequence(callsback(add_privacy_record))
  220.     
  221.     def block_buddy(self, buddy, callback = None):
  222.         self.add_privacy_record(buddy, oscar.ssi.deny_flag, callback = callback)
  223.  
  224.     block_buddy = callsback(block_buddy)
  225.     
  226.     def allow_buddy(self, buddy):
  227.         self.add_privacy_record(buddy, oscar.ssi.permit_flag)
  228.  
  229.     
  230.     def ignore_buddy(self, buddy, callback = None):
  231.         self.add_privacy_record(buddy, 14, callback = callback)
  232.  
  233.     ignore_buddy = callsback(ignore_buddy)
  234.     
  235.     def unignore_buddy(self, buddy, callback = None):
  236.         self.remove_privacy_record(buddy, type_ = 14, callback = callback)
  237.  
  238.     unignore_buddy = callsback(unignore_buddy)
  239.     
  240.     def remove_privacy_record(self, buddy, type_, callback = None):
  241.         yield None
  242.         me = None
  243.         name = _lowerstrip(common.get_bname(buddy))
  244.         buds_matching = self.find(name = name, type = type_)
  245.         errors = []
  246.         if buds_matching:
  247.             self.ssi_edit().__enter__()
  248.             
  249.             try:
  250.                 log.critical('REMOVING PRIVACY RECORD FOR ' + name)
  251.                 self._remove_ssi(buds_matching, me())
  252.             finally:
  253.                 pass
  254.  
  255.             yield None
  256.             errors = self.ssi_edit()
  257.         
  258.         for err, ssi in zip(errors, buds_matching):
  259.             if not err:
  260.                 del self.ssis[ssi]
  261.                 continue
  262.         
  263.         real_errors = filter(None, errors)
  264.         if not buds_matching:
  265.             log.critical("Can't remove privacy record; no ssi in root group for %s.", name)
  266.         
  267.         callback.success()
  268.         self.o.buddies[name].notify('blocked')
  269.         self.ssis.root_group.notify()
  270.  
  271.     remove_privacy_record = gen_sequence(callsback(remove_privacy_record))
  272.     
  273.     def unblock_buddy(self, buddy, callback = None):
  274.         self.remove_privacy_record(buddy, oscar.ssi.deny_flag, callback = callback)
  275.  
  276.     unblock_buddy = callsback(unblock_buddy)
  277.     
  278.     def unallow_buddy(self, buddy):
  279.         self.remove_privacy_record(buddy, oscar.ssi.permit_flag)
  280.  
  281.     
  282.     def get_privacy_ssi(self):
  283.         PDINFO = 4
  284.         privacy_infos = _[1]
  285.         if len(privacy_infos) == 0:
  286.             pinfo_ssi = item('', 0, self.new_ssi_item_id(0), PDINFO)
  287.         elif len(privacy_infos) == 1:
  288.             pinfo_ssi = privacy_infos[0]
  289.         else:
  290.             log.critical('There was more than one privacy SSI:')
  291.             log.critical(str(privacy_infos))
  292.             raise SSIException('There was more than one privacy SSI:')
  293.         return pinfo_ssi
  294.  
  295.     
  296.     def blocklist(self):
  297.         return _[1]
  298.  
  299.     
  300.     def ignorelist(self):
  301.         return _[1]
  302.  
  303.     
  304.     def find(self, f = (lambda x: True), **kwds):
  305.         results = []
  306.         for ssi in self.ssis.values():
  307.             for kwd in kwds:
  308.                 if kwd == 'name':
  309.                     if _lowerstrip(getattr(ssi, kwd, sentinel)) != _lowerstrip(kwds[kwd]):
  310.                         break
  311.                     
  312.                 _lowerstrip(getattr(ssi, kwd, sentinel)) != _lowerstrip(kwds[kwd])
  313.                 if getattr(ssi, kwd, sentinel) != kwds[kwd]:
  314.                     break
  315.                     continue
  316.             elif f(ssi):
  317.                 results.append(ssi)
  318.                 continue
  319.         
  320.         return results
  321.  
  322.     
  323.     def _add_to_group(self, group_ids, id_to_add, position):
  324.         yield None
  325.         me = None
  326.         groupclone = self.ssis[group_ids].clone()
  327.         groupclone.add_item_to_group(id_to_add, position)
  328.         yield self._modify_ssi(groupclone, me())
  329.         errors = None
  330.         self.ssis.root_group.notify()
  331.  
  332.     _add_to_group = gen_sequence(_add_to_group)
  333.     
  334.     def _remove_from_group(self, key):
  335.         yield None
  336.         me = None
  337.         (group_id, item_id) = tuple_key(key)
  338.         log.info('removing (%d, %d)', group_id, item_id)
  339.         if not item_id:
  340.             group_id = item_id
  341.             item_id = group_id
  342.         
  343.         group_clone = self.ssis[(group_id, 0)].clone()
  344.         group_clone.remove_item_from_group(item_id)
  345.         yield self._modify_ssi(group_clone, me())
  346.         error = None
  347.         self.ssis.root_group.notify()
  348.  
  349.     _remove_from_group = gen_sequence(_remove_from_group)
  350.     
  351.     def remove_group(self, group_protocol_object):
  352.         yield None
  353.         me = None
  354.         group_protocol_object = getattr(group_protocol_object, 'id', group_protocol_object)
  355.         ssis_to_del = self.get_ssis_in_group(group_protocol_object)
  356.         log.info('Going to remove: %r', ssis_to_del)
  357.         group_to_del = self.ssis[tuple_key(group_protocol_object)]
  358.         groupclone = group_to_del.clone()
  359.         groupclone.tlvs = { }
  360.         ssis_to_del.append(groupclone)
  361.         self.ssi_edit().__enter__()
  362.         
  363.         try:
  364.             self._remove_ssi(ssis_to_del, me())
  365.             yield None
  366.             errors = self.ssi_edit()
  367.             for ssi, error in zip(ssis_to_del, errors):
  368.                 if not error and ssi in self.ssis:
  369.                     del self.ssis[ssi]
  370.                     continue
  371.             
  372.             if group_protocol_object not in self.ssis:
  373.                 self._remove_from_group(group_protocol_object)
  374.         finally:
  375.             pass
  376.  
  377.         real_errors = filter(None, errors)
  378.         if real_errors:
  379.             raise SSIException('Error removing group from list: ' + ','.join((lambda .0: for err in .0:
  380. ssi_err_types[err])(real_errors)))
  381.         
  382.         self.ssis.root_group.notify()
  383.  
  384.     remove_group = gen_sequence(remove_group)
  385.     
  386.     def remove_buddy_ssi(self, ids, callback = None):
  387.         yield None
  388.         me = None
  389.         self.ssi_edit().__enter__()
  390.         
  391.         try:
  392.             buddy_clone = self.ssis[ids].clone()
  393.             yield self._remove_ssi(buddy_clone, me())
  394.             error = self.ssi_edit()
  395.             if not error[0]:
  396.                 self._remove_from_group(ids)
  397.                 del self.ssis[ids]
  398.                 callback.success()
  399.             else:
  400.                 callback.error()
  401.                 raise ','.join([] + []([ ssi_err_types[err] for err in error ]))
  402.         finally:
  403.             pass
  404.  
  405.         self.ssis.root_group.notify()
  406.  
  407.     remove_buddy_ssi = gen_sequence(callsback(remove_buddy_ssi))
  408.     
  409.     def rename_ssi(self, protocol_object, name):
  410.         yield None
  411.         me = None
  412.         new_ssi = self.ssis[protocol_object].clone()
  413.         new_ssi.name = name.encode('utf-8')
  414.         yield self._modify_ssi(new_ssi, me())
  415.         errors = None
  416.         self.ssis.root_group.notify()
  417.  
  418.     rename_ssi = gen_sequence(rename_ssi)
  419.     
  420.     def alias_ssi(self, contact, name):
  421.         yield None
  422.         me = None
  423.         buddy = contact.buddy
  424.         id = contact.id
  425.         new_ssi = self.ssis[id].clone()
  426.         name = None if name else None
  427.         new_ssi.set_alias(name)
  428.         yield self._modify_ssi(new_ssi, me())
  429.         errors = None
  430.         if errors[0]:
  431.             raise SSIException('Error setting alias: ' + ','.join((lambda .0: for err in .0:
  432. ssi_err_types[err])(errors)))
  433.         else:
  434.             self.ssis[id].set_alias(name)
  435.         self.ssis.root_group.notify()
  436.  
  437.     alias_ssi = gen_sequence(alias_ssi)
  438.     
  439.     def move_ssi_to_position(self, item_ids, position, group_to_ids = None, callback = None):
  440.         yield None
  441.         me = None
  442.         item_ids = tuple_key(item_ids)
  443.         if group_to_ids:
  444.             group_to_ids = tuple_key(group_to_ids)
  445.             if group_to_ids[1]:
  446.                 raise SSIException("Can't move items into something which is not a group.")
  447.             
  448.         
  449.         if not item_ids[0]:
  450.             raise AssertionError('Atttempted to move something in the ' + 'SSI root group (this is impossible, ' + "since they don't have position).")
  451.         elif not item_ids[1]:
  452.             group_from_ids = (0, 0)
  453.             if group_to_ids and group_to_ids != (0, 0):
  454.                 raise SSIException("Can't move group into a group which is not the root group.")
  455.             
  456.             id_to_move = item_ids[0]
  457.         else:
  458.             group_from_ids = (item_ids[0], 0)
  459.             id_to_move = item_ids[1]
  460.         callback.success((new_ssi.group_id, new_ssi.item_id))
  461.         self.ssis.root_group.notify()
  462.  
  463.     move_ssi_to_position = gen_sequence(callsback(move_ssi_to_position))
  464.     
  465.     def _edit_server_list_start(self, import_transaction = False):
  466.         if not self.ssi_edits_out:
  467.             self.o.send_snac(*snac.send_x13_x11(import_transaction))
  468.         
  469.         self.ssi_edits_out += 1
  470.  
  471.     
  472.     def _edit_server_list_end(self):
  473.         self.ssi_edits_out -= 1
  474.         if not self.ssi_edits_out:
  475.             self.o.send_snac(*snac.send_x13_x12())
  476.         
  477.  
  478.     
  479.     def ssi_edit(self, import_transaction = False):
  480.         self._edit_server_list_start(import_transaction)
  481.         
  482.         try:
  483.             yield self
  484.         finally:
  485.             self._edit_server_list_end()
  486.  
  487.  
  488.     ssi_edit = contextmanager(ssi_edit)
  489.  
  490.