home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2012 January / maximum-cd-2012-01.iso / DiscContents / digsby_setup.exe / lib / oscar / ssi / SSIManager.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2011-10-05  |  18.4 KB  |  609 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.6)
  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 oscar._lowerstrip(s)
  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().__exit__
  45.         if not errors[0]:
  46.             self.ssis[new_ssi] = new_ssi
  47.         else:
  48.             raise ','.join([] + []([ ssi_err_types[err] for err in errors ]))
  49.         return self.ssi_edit()
  50.  
  51.     add_modify = gen_sequence(add_modify)
  52.     
  53.     def new_ssi_item_id(self, group):
  54.         newid = 256
  55.         used_ids = set(self.generated_ssi_ids + self.ssis.keys())
  56.         while (group, newid) in used_ids:
  57.             newid += 1
  58.         self.generated_ssi_ids += [
  59.             (group, newid)]
  60.         return newid
  61.  
  62.     
  63.     def new_ssi_group_id(self):
  64.         newid = 256
  65.         used_ids = set(self.generated_ssi_ids + self.ssis.keys())
  66.         while (newid, 0) in used_ids:
  67.             newid += 1
  68.         self.generated_ssi_ids += [
  69.             (newid, 0)]
  70.         return newid
  71.  
  72.     
  73.     def get_ssis_in_group(self, group_id, with_group = False):
  74.         if with_group:
  75.             return _[1]
  76.         return _[2]
  77.  
  78.     
  79.     def get_ssis_by_type(self, type):
  80.         return _[1]
  81.  
  82.     
  83.     def _ssi_action(self, action, new_ssis, parent):
  84.         yield None
  85.         me = None
  86.         self.ssi_edit().__enter__()
  87.         
  88.         try:
  89.             self.o.send_snac(19, action, ''.join((lambda .0: for s in .0:
  90. s.to_bytes())(new_ssis)), req = True, cb = me.send)
  91.         finally:
  92.             pass
  93.  
  94.         yield None
  95.         self.ssi_edit().__exit__(parent.send(self.o.gen_incoming))
  96.  
  97.     _ssi_action = gen_sequence(_ssi_action)
  98.     
  99.     def _ssi_double_action(self, action1, new_ssis1, action2, new_ssis2, parent):
  100.         yield None
  101.         me = None
  102.         self.ssi_edit().__enter__()
  103.         
  104.         try:
  105.             if isinstance(new_ssis2, item):
  106.                 new_ssis2 = [
  107.                     new_ssis2]
  108.             
  109.             self.o.send_snac(19, action1, ''.join((lambda .0: for s in .0:
  110. s.to_bytes())(new_ssis1)), 5, True, me.send, action1)
  111.             self.o.send_snac(19, action2, ''.join((lambda .0: for s in .0:
  112. s.to_bytes())(new_ssis2)), 5, True, me.send, action2)
  113.         finally:
  114.             pass
  115.  
  116.         yield None
  117.         (sock1, snac1, ret_action1) = self.ssi_edit().__exit__
  118.         yield None
  119.         (sock2, snac2, ret_action2) = self.ssi_edit()
  120.         incoming1 = self.o.gen_incoming((sock1, snac1))
  121.         incoming2 = self.o.gen_incoming((sock2, snac2))
  122.         parent.send((incoming1, ret_action1, incoming2, ret_action2))
  123.  
  124.     _ssi_double_action = gen_sequence(_ssi_double_action)
  125.     
  126.     def _add_ssi(self, *a, **k):
  127.         self._ssi_action(8, *a, **k)
  128.  
  129.     
  130.     def _modify_ssi(self, *a, **k):
  131.         self._ssi_action(9, *a, **k)
  132.  
  133.     
  134.     def _remove_ssi(self, *a, **k):
  135.         self._ssi_action(10, *a, **k)
  136.  
  137.     
  138.     def add_new_ssi(self, name, group_protocol_object = None, position = 0, type_ = None, authorization = False, callback = None):
  139.         yield None
  140.         me = None
  141.         if not isinstance(name, str):
  142.             name = name.encode('utf-8')
  143.         
  144.         if group_protocol_object is not None:
  145.             group_protocol_object = tuple_key(group_protocol_object)
  146.             group_id = group_protocol_object[0]
  147.             item_id = self.new_ssi_item_id(group_protocol_object[0])
  148.             if type_ is None:
  149.                 type_ = 0
  150.             
  151.         else:
  152.             group_id = self.new_ssi_group_id()
  153.             item_id = 0
  154.             if type_ is None:
  155.                 type_ = 1
  156.             
  157.         new_ssi = item(name, group_id, item_id, type_)
  158.         if group_protocol_object is not None and authorization:
  159.             new_ssi.tlvs[102] = ''
  160.         
  161.         self.ssi_edit().__enter__()
  162.         
  163.         try:
  164.             yield self._add_ssi(new_ssi, me())
  165.             errors = self.ssi_edit().__exit__
  166.             if not errors[0]:
  167.                 self.ssis[new_ssi] = new_ssi
  168.                 if not group_protocol_object:
  169.                     pass
  170.                 ids = (0, 0)
  171.                 id_to_add = self.ssi_edit() if group_protocol_object else new_ssi.group_id
  172.                 self._add_to_group(ids, id_to_add, position)
  173.             else:
  174.                 callback.error()
  175.                 if errors[0] != 14:
  176.                     raise ','.join([] % ([]([ ssi_err_types[err] for err in errors ]), new_ssi))
  177.                 errors[0] != 14
  178.         finally:
  179.             pass
  180.  
  181.         
  182.         try:
  183.             log.info(','.join((lambda .0: for g in .0:
  184. g.name)(self.ssis.root_group)))
  185.         except:
  186.             self.ssi_edit().__exit__
  187.             self.ssi_edit()
  188.             log.error('error repr-ing groups')
  189.  
  190.         self.ssis.root_group.notify()
  191.         callback.success(new_ssi)
  192.  
  193.     add_new_ssi = gen_sequence(callsback(add_new_ssi))
  194.     
  195.     def add_privacy_record(self, buddy, type_, callback = None):
  196.         yield None
  197.         me = None
  198.         name = common.get_bname(buddy)
  199.         self.ssi_edit().__enter__()
  200.         
  201.         try:
  202.             if not (self.find,)((lambda s: _lowerstrip(s.name) == _lowerstrip(name)), type = type_):
  203.                 log.critical('adding ' + name + ' to your privacy list')
  204.                 buddy_ssi = item(name, 0, self.new_ssi_item_id(0), type_)
  205.                 yield self._add_ssi(buddy_ssi, me())
  206.                 buddy_errs = self.ssi_edit().__exit__
  207.                 log.critical('ACK PRIVACY MOD!' + name)
  208.                 if not buddy_errs[0]:
  209.                     self.ssis[buddy_ssi] = buddy_ssi
  210.                 else:
  211.                     callback.error()
  212.                     raise ','.join([] + []([ ssi_err_types[err] for err in buddy_errs ]))
  213.             buddy_errs[0]
  214.             callback.error()
  215.             raise SSIException('Buddy already in that privacy list.')
  216.         finally:
  217.             pass
  218.  
  219.         callback.success()
  220.         self.ssis.root_group.notify()
  221.  
  222.     add_privacy_record = gen_sequence(callsback(add_privacy_record))
  223.     
  224.     def block_buddy(self, buddy, callback = None):
  225.         self.add_privacy_record(buddy, oscar.ssi.deny_flag, callback = callback)
  226.  
  227.     block_buddy = callsback(block_buddy)
  228.     
  229.     def allow_buddy(self, buddy):
  230.         self.add_privacy_record(buddy, oscar.ssi.permit_flag)
  231.  
  232.     
  233.     def ignore_buddy(self, buddy, callback = None):
  234.         self.add_privacy_record(buddy, 14, callback = callback)
  235.  
  236.     ignore_buddy = callsback(ignore_buddy)
  237.     
  238.     def unignore_buddy(self, buddy, callback = None):
  239.         self.remove_privacy_record(buddy, type_ = 14, callback = callback)
  240.  
  241.     unignore_buddy = callsback(unignore_buddy)
  242.     
  243.     def remove_privacy_record(self, buddy, type_, callback = None):
  244.         yield None
  245.         me = None
  246.         name = _lowerstrip(common.get_bname(buddy))
  247.         buds_matching = self.find(name = name, type = type_)
  248.         errors = []
  249.         if buds_matching:
  250.             self.ssi_edit().__enter__()
  251.             
  252.             try:
  253.                 log.critical('REMOVING PRIVACY RECORD FOR ' + name)
  254.                 self._remove_ssi(buds_matching, me())
  255.             finally:
  256.                 pass
  257.  
  258.             yield None
  259.             errors = self.ssi_edit().__exit__
  260.         
  261.         for err, ssi in zip(errors, buds_matching):
  262.             if not err:
  263.                 del self.ssis[ssi]
  264.                 continue
  265.         
  266.         real_errors = filter(None, errors)
  267.         if not buds_matching:
  268.             log.critical("Can't remove privacy record; no ssi in root group for %r (type = %r).", name, type_)
  269.         
  270.         if real_errors:
  271.             callback.error()
  272.             raise ','.join([] + []([ ssi_err_types[err] for err in errors ]))
  273.         real_errors
  274.         callback.success()
  275.         self.o.buddies[name].notify('blocked')
  276.         self.ssis.root_group.notify()
  277.  
  278.     remove_privacy_record = gen_sequence(callsback(remove_privacy_record))
  279.     
  280.     def unblock_buddy(self, buddy, callback = None):
  281.         self.remove_privacy_record(buddy, oscar.ssi.deny_flag, callback = callback)
  282.  
  283.     unblock_buddy = callsback(unblock_buddy)
  284.     
  285.     def unallow_buddy(self, buddy):
  286.         self.remove_privacy_record(buddy, oscar.ssi.permit_flag)
  287.  
  288.     
  289.     def get_privacy_ssi(self):
  290.         PDINFO = 4
  291.         privacy_infos = _[1]
  292.         if len(privacy_infos) == 0:
  293.             pinfo_ssi = item('', 0, self.new_ssi_item_id(0), PDINFO)
  294.         elif len(privacy_infos) == 1:
  295.             pinfo_ssi = privacy_infos[0]
  296.         else:
  297.             log.critical('There was more than one privacy SSI:')
  298.             log.critical(str(privacy_infos))
  299.             raise SSIException('There was more than one privacy SSI:')
  300.         return []
  301.  
  302.     
  303.     def blocklist(self):
  304.         return _[1]
  305.  
  306.     
  307.     def ignorelist(self):
  308.         return _[1]
  309.  
  310.     
  311.     def find(self, f = (lambda x: True), **kwds):
  312.         results = []
  313.         for ssi in self.ssis.values():
  314.             for kwd in kwds:
  315.                 if kwd == 'name':
  316.                     if _lowerstrip(getattr(ssi, kwd, sentinel)) != _lowerstrip(kwds[kwd]):
  317.                         break
  318.                     
  319.                 _lowerstrip(getattr(ssi, kwd, sentinel)) != _lowerstrip(kwds[kwd])
  320.                 if getattr(ssi, kwd, sentinel) != kwds[kwd]:
  321.                     break
  322.                     continue
  323.             elif f(ssi):
  324.                 results.append(ssi)
  325.                 continue
  326.         
  327.         return results
  328.  
  329.     
  330.     def _add_to_group(self, group_ids, id_to_add, position):
  331.         yield None
  332.         me = None
  333.         
  334.         try:
  335.             groupclone = self.ssis[group_ids].clone()
  336.         except KeyError:
  337.             raise SSIException('Could not find SSI with group_id == %r', group_ids)
  338.  
  339.         groupclone.add_item_to_group(id_to_add, position)
  340.         yield self._modify_ssi(groupclone, me())
  341.         errors = None
  342.         if errors[0] == 0:
  343.             self.ssis[group_ids].add_item_to_group(id_to_add, position)
  344.         else:
  345.             raise ', '.join([] + []([ ssi_err_types[err] for err in errors ]))
  346.         (errors[0] == 0).ssis.root_group.notify()
  347.  
  348.     _add_to_group = gen_sequence(_add_to_group)
  349.     
  350.     def _remove_from_group(self, key):
  351.         yield None
  352.         me = None
  353.         (group_id, item_id) = tuple_key(key)
  354.         log.info('removing (%d, %d)', group_id, item_id)
  355.         if not item_id:
  356.             group_id = item_id
  357.             item_id = group_id
  358.         
  359.         group_clone = self.ssis[(group_id, 0)].clone()
  360.         group_clone.remove_item_from_group(item_id)
  361.         yield self._modify_ssi(group_clone, me())
  362.         error = None
  363.         if not error[0]:
  364.             self.ssis[(group_id, 0)].remove_item_from_group(item_id)
  365.         else:
  366.             raise ','.join([] + []([ ssi_err_types[err] for err in error ]))
  367.         error[0].ssis.root_group.notify()
  368.  
  369.     _remove_from_group = gen_sequence(_remove_from_group)
  370.     
  371.     def remove_group(self, group_protocol_object):
  372.         yield None
  373.         me = None
  374.         group_protocol_object = getattr(group_protocol_object, 'id', group_protocol_object)
  375.         ssis_to_del = self.get_ssis_in_group(group_protocol_object)
  376.         log.info('Going to remove: %r', ssis_to_del)
  377.         group_to_del = self.ssis[tuple_key(group_protocol_object)]
  378.         groupclone = group_to_del.clone()
  379.         groupclone.tlvs = { }
  380.         ssis_to_del.append(groupclone)
  381.         self.ssi_edit().__enter__()
  382.         
  383.         try:
  384.             self._remove_ssi(ssis_to_del, me())
  385.             yield None
  386.             errors = self.ssi_edit().__exit__
  387.             for ssi, error in zip(ssis_to_del, errors):
  388.                 if not error and ssi in self.ssis:
  389.                     del self.ssis[ssi]
  390.                     continue
  391.                 self.ssi_edit()
  392.             
  393.             if group_protocol_object not in self.ssis:
  394.                 self._remove_from_group(group_protocol_object)
  395.         finally:
  396.             pass
  397.  
  398.         real_errors = filter(None, errors)
  399.         if real_errors:
  400.             raise SSIException('Error removing group from list: ' + ','.join((lambda .0: for err in .0:
  401. ssi_err_types[err])(real_errors)))
  402.         real_errors
  403.         self.ssis.root_group.notify()
  404.  
  405.     remove_group = gen_sequence(remove_group)
  406.     
  407.     def remove_buddy_ssi(self, ids, callback = None):
  408.         yield None
  409.         me = None
  410.         self.ssi_edit().__enter__()
  411.         
  412.         try:
  413.             buddy_clone = self.ssis[ids].clone()
  414.             yield self._remove_ssi(buddy_clone, me())
  415.             error = self.ssi_edit().__exit__
  416.             if not error[0]:
  417.                 self._remove_from_group(ids)
  418.                 del self.ssis[ids]
  419.                 callback.success()
  420.             else:
  421.                 callback.error()
  422.                 raise ','.join([] + []([ ssi_err_types[err] for err in error ]))
  423.             self.ssis.root_group.notify()
  424.             return None
  425.  
  426.  
  427.     remove_buddy_ssi = gen_sequence(callsback(remove_buddy_ssi))
  428.     
  429.     def rename_ssi(self, protocol_object, name):
  430.         yield None
  431.         me = None
  432.         new_ssi = self.ssis[protocol_object].clone()
  433.         new_ssi.name = name.encode('utf-8')
  434.         yield self._modify_ssi(new_ssi, me())
  435.         errors = None
  436.         if errors[0]:
  437.             raise ','.join([] + []([ ssi_err_types[err] for err in errors ]))
  438.         errors[0]
  439.         ssiobj = self.ssis[protocol_object]
  440.         ssiobj.name = name.encode('utf-8')
  441.         self.ssis.get_group(protocol_object).set_ssi(ssiobj)
  442.         self.ssis.root_group.notify()
  443.  
  444.     rename_ssi = gen_sequence(rename_ssi)
  445.     
  446.     def alias_ssi(self, contact, name):
  447.         yield None
  448.         me = None
  449.         buddy = contact.buddy
  450.         id = contact.id
  451.         new_ssi = self.ssis[id].clone()
  452.         name = None if name else None
  453.         new_ssi.set_alias(name)
  454.         yield self._modify_ssi(new_ssi, me())
  455.         errors = None
  456.         if errors[0]:
  457.             raise SSIException('Error setting alias: ' + ','.join((lambda .0: for err in .0:
  458. ssi_err_types[err])(errors)))
  459.         errors[0]
  460.         self.ssis[id].set_alias(name)
  461.         self.ssis.root_group.notify()
  462.  
  463.     alias_ssi = gen_sequence(alias_ssi)
  464.     
  465.     def move_ssi_to_position(self, item_ids, position, group_to_ids = None, callback = None):
  466.         yield None
  467.         me = None
  468.         item_ids = tuple_key(item_ids)
  469.         if group_to_ids:
  470.             group_to_ids = tuple_key(group_to_ids)
  471.             if group_to_ids[1]:
  472.                 raise SSIException("Can't move items into something which is not a group.")
  473.             group_to_ids[1]
  474.         
  475.         if not item_ids[0]:
  476.             raise AssertionError('Atttempted to move something in the ' + 'SSI root group (this is impossible, ' + "since they don't have position).")
  477.         item_ids[0]
  478.         if not item_ids[1]:
  479.             group_from_ids = (0, 0)
  480.             if group_to_ids and group_to_ids != (0, 0):
  481.                 raise SSIException("Can't move group into a group which is not the root group.")
  482.             group_to_ids != (0, 0)
  483.             id_to_move = item_ids[0]
  484.         else:
  485.             group_from_ids = (item_ids[0], 0)
  486.             id_to_move = item_ids[1]
  487.         if not group_to_ids or group_from_ids == group_to_ids:
  488.             groupclone = self.ssis[group_from_ids].clone()
  489.             groupclone.move_item_to_position(id_to_move, position)
  490.             yield self._modify_ssi(groupclone, me())
  491.             errors = None
  492.             if not errors[0]:
  493.                 self.ssis[group_from_ids].move_item_to_position(id_to_move, position)
  494.             else:
  495.                 raise ','.join([] + []([ ssi_err_types[err] for err in errors ]))
  496.         errors[0]
  497.         del id_to_move
  498.         if not group_to_ids[0]:
  499.             raise AssertionError('atttempted to move something to the ' + 'SSI root group (this is impossible, ' + "since they don't have position)")
  500.         group_to_ids[0]
  501.         old_ssi = self.ssis[item_ids]
  502.         new_ssi = old_ssi.clone()
  503.         new_ssi.group_id = group_to_ids[0]
  504.         new_ssi.item_id = self.new_ssi_item_id(group_to_ids[0])
  505.         self.ssi_edit().__enter__()
  506.         
  507.         try:
  508.             yield self._ssi_double_action(10, old_ssi, 8, new_ssi, me())
  509.             (del_errors, action1, add_errors, action2) = self.ssi_edit().__exit__
  510.             if action1 != 10:
  511.                 del_errors = add_errors
  512.                 add_errors = del_errors
  513.             
  514.             (del_group_clone, add_group_clone) = (None, None)
  515.             if not del_errors[0]:
  516.                 del self.ssis[old_ssi]
  517.                 del_group_clone = self.ssis[(old_ssi.group_id, 0)].clone()
  518.                 del_group_clone.remove_item_from_group(old_ssi.item_id)
  519.             
  520.             if not add_errors[0]:
  521.                 self.ssis[new_ssi] = new_ssi
  522.                 add_group_clone = self.ssis[(new_ssi.group_id, 0)].clone()
  523.                 add_group_clone.add_item_to_group(new_ssi.item_id, position)
  524.             
  525.             mod_ssis = filter(None, [
  526.                 del_group_clone,
  527.                 add_group_clone])
  528.             self._modify_ssi(mod_ssis, me())
  529.         finally:
  530.             pass
  531.  
  532.         yield None
  533.         mod_errors = self.ssi_edit().__exit__
  534.         del_mod_error = None
  535.         add_mod_error = None
  536.         if not del_errors[0]:
  537.             del_mod_error = mod_errors[0]
  538.             mod_errors = mod_errors[1:]
  539.             if not del_mod_error:
  540.                 self.ssis[(old_ssi.group_id, 0)].remove_item_from_group(old_ssi.item_id)
  541.             
  542.         
  543.         if not add_errors[0]:
  544.             add_mod_error = mod_errors[0]
  545.             if not add_mod_error:
  546.                 self.ssis[(new_ssi.group_id, 0)].add_item_to_group(new_ssi.item_id, position)
  547.             
  548.         
  549.         errors = filter(None, (add_errors[0], del_errors[0], del_mod_error, add_mod_error))
  550.         if errors:
  551.             err_string = ''
  552.             if del_errors[0]:
  553.                 if err_string:
  554.                     err_string += ', '
  555.                 
  556.                 err_string += 'deleting ' + old_ssi.name + ' in group ' + self.ssis[(old_ssi.group_id, 0)].name
  557.             
  558.             if del_mod_error:
  559.                 if err_string:
  560.                     err_string += ', '
  561.                 
  562.                 err_string += 'removing ' + old_ssi.name + ' from group ' + self.ssis[(old_ssi.group_id, 0)].name + ' list'
  563.             
  564.             if add_errors[0]:
  565.                 if err_string:
  566.                     err_string += ', '
  567.                 
  568.                 err_string += 'adding ' + old_ssi.name + ' in group ' + self.ssis[(new_ssi.group_id, 0)].name
  569.             
  570.             if add_mod_error:
  571.                 if err_string:
  572.                     err_string += ', '
  573.                 
  574.                 err_string += 'adding ' + old_ssi.name + ' to group ' + self.ssis[(new_ssi.group_id, 0)].name + ' list'
  575.             
  576.             callback.error()
  577.             raise err_string(','.join % ([], []([ ssi_err_types[err] for err in errors ])))
  578.         errors
  579.         callback.success((new_ssi.group_id, new_ssi.item_id))
  580.         self.ssis.root_group.notify()
  581.  
  582.     move_ssi_to_position = gen_sequence(callsback(move_ssi_to_position))
  583.     
  584.     def _edit_server_list_start(self, import_transaction = False):
  585.         if not self.ssi_edits_out:
  586.             self.o.send_snac(*snac.send_x13_x11(import_transaction))
  587.         
  588.         self.ssi_edits_out += 1
  589.  
  590.     
  591.     def _edit_server_list_end(self):
  592.         self.ssi_edits_out -= 1
  593.         if not self.ssi_edits_out:
  594.             self.o.send_snac(*snac.send_x13_x12())
  595.         
  596.  
  597.     
  598.     def ssi_edit(self, import_transaction = False):
  599.         self._edit_server_list_start(import_transaction)
  600.         
  601.         try:
  602.             yield self
  603.         finally:
  604.             self._edit_server_list_end()
  605.  
  606.  
  607.     ssi_edit = contextmanager(ssi_edit)
  608.  
  609.