def _session_started(self): categories_dict = {} default_group = e3.Group('Friends', 'Friends') group_group = e3.Group('Groups', 'Groups') categories_dict[0] = default_group categories_dict[-1] = group_group for index in self.res_manager.categories: key = index.key() group = e3.Group(self.res_manager.categories[key].name, key) categories_dict[key] = group for uin in self.res_manager.contacts: key = uin.key() #nick = self.res_manager.contacts[uin].nick _status = e3.status.OFFLINE try: if not self.res_manager.contacts[key].status == '': _status = STATUS_MAP_REVERSE[ self.res_manager.contacts[key].status] except KeyError, e: _stauts = e3.status.ONLINE contact = e3.Contact(account=key, identifier=str(key), message=self.res_manager.contacts[key].lnick, _status=_status, blocked=False, cid=key) index = self.res_manager.contacts[key].cate_index group = categories_dict[index] self._add_contact_to_group(contact, group.name) self.session.contacts.contacts[key] = contact
def _search_item(self, uid, parent): '''Searches na item, given its uid''' if parent == self: item_locator = parent.item else: item_locator = parent.child num_rows = parent.rowCount() for i in range(num_rows): found_item = item_locator(i, 0) found_uid = found_item.data(Role.UidRole).toString() if found_uid == QtCore.QString(str(uid)).trimmed(): return found_item if uid in [self.NO_GRP_UID, self.ONL_GRP_UID, self.OFF_GRP_UID]: if uid == self.NO_GRP_UID: group = e3.Group(tr("No group"), identifier=uid, type_=e3.Group.NONE) elif uid == self.ONL_GRP_UID: group = e3.Group(tr("Online"), identifier=uid, type_=e3.Group.ONLINE) group.type = e3.Group.ONLINE elif uid == self.OFF_GRP_UID: group = e3.Group(tr("Offline"), identifier=uid, type_=e3.Group.OFFLINE) new_group_item = self.add_group(group, force=True) return new_group_item
def test_add_groups(self): g1 = e3.Group("group 1", "g1") g2 = e3.Group("group 2", "g2") groups = {g1.identifier: g1, g2.identifier: g2} logger.add_groups(groups) # add twice to check that they are only added once logger.add_groups(groups) time.sleep(1) self.assertEquals(len(logger.logger.groups), 2)
def handle_response(self, request, response): '''handle the response''' if response.status == 200: self.session.groups[self.gid] = e3.Group(self.name, self.gid) self.session.add_event(e3.Event.EVENT_GROUP_RENAME_SUCCEED, self.gid, self.name) else: log.debug(response.body + '\n' + request.body) self.session.add_event(e3.Event.EVENT_GROUP_RENAME_FAILED, self.gid, self.name)
def handle_response(self, request, response): '''handle the response''' if response.status == 200: gid = common.get_value_between(response.body, '<guid>', '</guid>') self.session.groups[gid] = e3.Group(self.name, gid) self.session.add_event(e3.Event.EVENT_GROUP_ADD_SUCCEED, self.name, gid) else: log.debug(response.body + '\n' + request.body) self.session.add_event(e3.Event.EVENT_GROUP_ADD_FAILED, self.name)
def _start_from_cache(self): '''try to send the adl with the data from cache''' logger = self.session.logger.logger if len(logger.accounts) < 2: return False # thread madness I should be careful to not modify accounts while # iterating for (account, contact) in logger.accounts.items(): new_contact = e3.Contact(account, contact.cid, contact.nick, contact.message) new_contact.groups = contact.groups[:] self.session.contacts.contacts[account] = new_contact for (gid, group) in logger.groups.iteritems(): new_group = e3.Group(group.name, gid) new_group.contacts = group.accounts[:] self.session.groups[gid] = new_group nick = my_account = self.session.account.account account_info = logger.accounts.get(my_account, None) if account_info: if account_info.nick: nick = account_info.nick else: nick = my_account nick = nick.decode('utf-8', 'replace').encode('utf-8') self.socket.send_command('PRP', ('MFN', urllib.quote(nick))) self.session.add_event(e3.Event.EVENT_NICK_CHANGE_SUCCEED, nick) self.socket.send_command('BLP', ('BL', )) for adl in self.session.contacts.get_adls(): self.socket.send_command('ADL', payload=adl) self.session.add_event(e3.Event.EVENT_CONTACT_LIST_READY) return True
def add_contact(self, contact, group=None): '''add a contact to the contact list, add it to the group if group is not None''' try: weight = int(self.session.config.d_weights.get(contact.account, 0)) except ValueError: weight = 0 self.session.config.d_weights[contact.account] = weight offline = contact.status == e3.status.OFFLINE is_online = not offline contact_data = ( self._get_contact_pixbuf_or_default(contact), contact, self.format_nick(contact), True, utils.safe_gtk_pixbuf_load( gui.theme.image_theme.status_icons[contact.status]), weight, False, offline) # if group_offline is set and the contact is offline then put it on the # special offline group if self.group_offline and offline: duplicate = self._duplicate_check(contact) if duplicate is not None: return duplicate if not self.offline_group: self.session.config.d_weights['1'] = 0 self.offline_group = e3.Group(_("Offline"), identifier='1', type_=e3.Group.OFFLINE) self.offline_group_iter = self.add_group( self.offline_group, True) self.offline_group.contacts.append(contact.account) self.update_offline_group() return self._model.append(self.offline_group_iter, contact_data) # if we are in order by status mode and contact is online, # we add online contacts to their online group :) if self.order_by_status and is_online: duplicate = self._duplicate_check(contact) if duplicate is not None: return duplicate if not self.online_group: self.session.config.d_weights['0'] = 1 self.online_group = e3.Group(_("Online"), identifier='0', type_=e3.Group.ONLINE) self.online_group_iter = self.add_group( self.online_group, True) self.online_group.contacts.append(contact.account) self.update_online_group() return self._model.append(self.online_group_iter, contact_data) # if it has no group and we are in order by group then add it to the # special group "No group" if not group and not self.order_by_status: if self.no_group: self.no_group.contacts.append(contact.account) self.update_no_group() return self._model.append(self.no_group_iter, contact_data) else: self.no_group = e3.Group(_("No group"), identifier='0', type_=e3.Group.NONE) self.no_group_iter = self.add_group(self.no_group, True) self.no_group.contacts.append(contact.account) self.update_no_group() return self._model.append(self.no_group_iter, contact_data) # if no group add it to the root, but check that it's not on a group # or in the root already if not group or self.order_by_status: for row in self._model: obj = row[1] # check on group if isinstance(obj, e3.Group): for contact_row in row.iterchildren(): con = contact_row[1] if con.account == contact.account: return contact_row.iter # check on the root elif isinstance(obj, e3.Contact) and obj.account == contact.account: return row.iter return self._model.append(None, contact_data) for row in self._model: obj = row[1] if isinstance(obj, e3.Group) and obj.name == group.name: # if the contact is already on the group, then dont add it for contact_row in row.iterchildren(): con = contact_row[1] if con.account == contact.account: return contact_row.iter return_iter = self._model.append(row.iter, contact_data) self.update_group(group) # search the use on the root to remove it if it's there # since we added him to a group for irow in self._model: iobj = irow[1] if isinstance(iobj, e3.Contact) and \ iobj.account == contact.account: del self._model[irow.iter] return return_iter else: #######WTF??? where does this belong??? self.add_group(group) result = self.add_contact(contact, group) self.update_group(group) return result
def _add_group(self, name): """ method to add a group to the contact list """ self.session.groups[name] = e3.Group(name, name)
def handle_response(self, request, response): '''handle the response''' if response.status == 200: parser = XmlParser.DynamicParser(response.body) # Retrieve groups for group_dict in parser.groups: group_id = group_dict['groupId'] group_name = group_dict['name'] if group_id in self.session.groups: self.session.groups[group_id].name = group_name else: self.session.groups[group_id] = \ e3.Group(group_name, group_id) # Retrieve contacts for contact_dict in parser.contacts: if 'isMessengerUser' in contact_dict \ and 'passportName' in contact_dict \ and contact_dict['isMessengerUser'] == 'true': # valid email = contact_dict['passportName'].lower() if email in self.session.contacts.contacts: contact = self.session.contacts.contacts[email] else: contact = e3.Contact(email) self.session.contacts.contacts[email] = contact else: continue contact.identifier = contact_dict.get('contactId', '') contact.cid = contact_dict.get('CID', '') contact.groups = [] for guid in contact_dict['groupIds']: contact.groups.append(guid) group = self.session.groups[guid] if contact.account not in group.contacts: group.contacts.append(contact.account) for ann in contact_dict['Annotations']: if ann.get('Name', None) == 'AB.NickName': contact.alias = urllib.unquote(ann['Value']) break if not contact.nick: contact.nick = urllib.unquote(contact_dict.get( 'displayName', contact.account)) contact.attrs['mobile'] = \ contact_dict.get('isMobileIMEnabled', None) == 'true' contact.attrs['space'] = \ contact_dict.get('hasSpace', None) == 'true' log.debug('dynamic finished') self.session.contacts.me.identifier = \ response.body.split('<contactType>Me</contactType>')\ [1].split('</CID>')[0].split('<CID>')[1].strip() # get our nick try: nick = response.body.split('<contactType>Me</contactType>')\ [1].split('</displayName>')[0].split('<displayName>')[1] nick = common.unescape(nick) except IndexError: nick = self.session.contacts.me.account if not self.session.contacts.me.nick or \ self.session.contacts.me != self.session.account.account: self.session.contacts.me.nick = nick if self.on_login: # set our nick self.command_queue.put(Command('PRP', params=('MFN', urllib.quote(nick)))) self.session.add_event(e3.Event.EVENT_NICK_CHANGE_SUCCEED, nick) if not self.started_from_cache: self.command_queue.put(Command('BLP', params=('BL',))) accounts = self.session.contacts.pending.keys() for account in accounts: # account in pending that is already on some other role # (corrupted userlist) if account in self.session.contacts.contacts or account in self.session.contacts.reverse: del self.session.contacts.pending[account] # this line doen't work for accounts on corrupted userlists # RemovePendingContact(self.session, account).start() self.session.add_event(e3.Event.EVENT_CONTACT_LIST_READY) self.session.logger.add_contact_by_group( self.session.contacts.contacts, self.session.groups) if not self.started_from_cache: for adl in self.session.contacts.get_adls(): self.command_queue.put(Command('ADL', payload=adl)) GetProfile(self.session, self.session.contacts.me.identifier).start() else: log.debug('error requestion dynamic items')