common.contacts

1 # -*- coding:utf-8 -*- 2 ## src/common/contacts.py 3 ## 4 ## Copyright (C) 2006 Dimitur Kirov <dkirov AT gmail.com> 5 ## Travis Shirk <travis AT pobox.com> 6 ## Nikos Kouremenos <kourem AT gmail.com> 7 ## Copyright (C) 2006-2010 Yann Leboulanger <asterix AT lagaule.org> 8 ## Jean-Marie Traissard <jim AT lapin.org> 9 ## Copyright (C) 2007 Lukas Petrovicky <lukas AT petrovicky.net> 10 ## Tomasz Melcer <liori AT exroot.org> 11 ## Julien Pivotto <roidelapluie AT gmail.com> 12 ## Copyright (C) 2007-2008 Stephan Erb <steve-e AT h3c.de> 13 ## Copyright (C) 2008 Brendan Taylor <whateley AT gmail.com> 14 ## Jonathan Schleifer <js-gajim AT webkeks.org> 15 ## 16 ## This file is part of Gajim. 17 ## 18 ## Gajim is free software; you can redistribute it and/or modify 19 ## it under the terms of the GNU General Public License as published 20 ## by the Free Software Foundation; version 3 only. 21 ## 22 ## Gajim is distributed in the hope that it will be useful, 23 ## but WITHOUT ANY WARRANTY; without even the implied warranty of 24 ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 25 ## GNU General Public License for more details. 26 ## 27 ## You should have received a copy of the GNU General Public License 28 ## along with Gajim. If not, see <http://www.gnu.org/licenses/>. 29 ## 30 31 32 from common import caps_cache 33 from common.account import Account 34 import common.gajim 35

36 -class XMPPEntity(object):

37 """ 38 Base representation of entities in XMPP 39 """ 40

41 - def __init__(self, jid, account, resource):

42 self.jid = jid 43 self.resource = resource 44 self.account = account

45

46 -class CommonContact(XMPPEntity):

47

48 - def __init__(self, jid, account, resource, show, status, name, 49 our_chatstate, composing_xep, chatstate, client_caps=None):

50 51 XMPPEntity.__init__(self, jid, account, resource) 52 53 self.show = show 54 self.status = status 55 self.name = name 56 57 self.client_caps = client_caps or caps_cache.NullClientCaps() 58 59 # please read xep-85 http://www.xmpp.org/extensions/xep-0085.html 60 # we keep track of xep85 support with the peer by three extra states: 61 # None, False and 'ask' 62 # None if no info about peer 63 # False if peer does not support xep85 64 # 'ask' if we sent the first 'active' chatstate and are waiting for reply 65 # this holds what WE SEND to contact (our current chatstate) 66 self.our_chatstate = our_chatstate 67 # tell which XEP we're using for composing state 68 # None = have to ask, XEP-0022 = use this xep, 69 # XEP-0085 = use this xep, False = no composing support 70 self.composing_xep = composing_xep 71 # this is contact's chatstate 72 self.chatstate = chatstate

73

74 - def get_full_jid(self):

75 raise NotImplementedError

76

77 - def get_shown_name(self):

78 raise NotImplementedError

79

80 - def supports(self, requested_feature):

81 """ 82 Return True if the contact has advertised to support the feature 83 identified by the given namespace. False otherwise. 84 """ 85 if self.show == 'offline': 86 # Unfortunately, if all resources are offline, the contact 87 # includes the last resource that was online. Check for its 88 # show, so we can be sure it's existant. Otherwise, we still 89 # return caps for a contact that has no resources left. 90 return False 91 else: 92 return caps_cache.client_supports(self.client_caps, requested_feature)

93 94

95 -class Contact(CommonContact):

96 """ 97 Information concerning a contact 98 """

99 - def __init__(self, jid, account, name='', groups=[], show='', status='', 100 sub='', ask='', resource='', priority=0, keyID='', client_caps=None, 101 our_chatstate=None, chatstate=None, last_status_time=None, msg_id= 102 None, composing_xep=None, last_activity_time=None):

103 104 CommonContact.__init__(self, jid, account, resource, show, status, name, 105 our_chatstate, composing_xep, chatstate, client_caps=client_caps) 106 107 self.contact_name = '' # nick choosen by contact 108 self.groups = [i for i in set(groups)] # filter duplicate values 109 110 self.sub = sub 111 self.ask = ask 112 113 self.priority = priority 114 self.keyID = keyID 115 self.msg_id = msg_id 116 self.last_status_time = last_status_time 117 self.last_activity_time = last_activity_time 118 119 self.pep = {}

120

121 - def get_full_jid(self):

122 if self.resource: 123 return self.jid + '/' + self.resource 124 return self.jid

125

126 - def get_shown_name(self):

127 if self.name: 128 return self.name 129 if self.contact_name: 130 return self.contact_name 131 return self.jid.split('@')[0]

132

133 - def get_shown_groups(self):

134 if self.is_observer(): 135 return [_('Observers')] 136 elif self.is_groupchat(): 137 return [_('Groupchats')] 138 elif self.is_transport(): 139 return [_('Transports')] 140 elif not self.groups: 141 return [_('General')] 142 else: 143 return self.groups

144

145 - def is_hidden_from_roster(self):

146 """ 147 If contact should not be visible in roster 148 """ 149 # XEP-0162: http://www.xmpp.org/extensions/xep-0162.html 150 if self.is_transport(): 151 return False 152 if self.sub in ('both', 'to'): 153 return False 154 if self.sub in ('none', 'from') and self.ask == 'subscribe': 155 return False 156 if self.sub in ('none', 'from') and (self.name or len(self.groups)): 157 return False 158 if _('Not in Roster') in self.groups: 159 return False 160 return True

161

162 - def is_observer(self):

163 # XEP-0162: http://www.xmpp.org/extensions/xep-0162.html 164 is_observer = False 165 if self.sub == 'from' and not self.is_transport()\ 166 and self.is_hidden_from_roster(): 167 is_observer = True 168 return is_observer

169

170 - def is_groupchat(self):

171 for account in common.gajim.gc_connected: 172 if self.jid in common.gajim.gc_connected[account]: 173 return True 174 return False

175

176 - def is_transport(self):

177 # if not '@' or '@' starts the jid then contact is transport 178 return self.jid.find('@') <= 0

179 180

181 -class GC_Contact(CommonContact):

182 """ 183 Information concerning each groupchat contact 184 """ 185

186 - def __init__(self, room_jid, account, name='', show='', status='', role='', 187 affiliation='', jid='', resource='', our_chatstate=None, 188 composing_xep=None, chatstate=None):

189 190 CommonContact.__init__(self, jid, account, resource, show, status, name, 191 our_chatstate, composing_xep, chatstate) 192 193 self.room_jid = room_jid 194 self.role = role 195 self.affiliation = affiliation

196

197 - def get_full_jid(self):

198 return self.room_jid + '/' + self.name

199

200 - def get_shown_name(self):

201 return self.name

202

203 - def as_contact(self):

204 """ 205 Create a Contact instance from this GC_Contact instance 206 """ 207 return Contact(jid=self.get_full_jid(), account=self.account, 208 name=self.name, groups=[], show=self.show, status=self.status, 209 sub='none', client_caps=self.client_caps)

210 211

212 -class LegacyContactsAPI:

213 """ 214 This is a GOD class for accessing contact and groupchat information. 215 The API has several flaws: 216 217 * it mixes concerns because it deals with contacts, groupchats, 218 groupchat contacts and metacontacts 219 * some methods like get_contact() may return None. This leads to 220 a lot of duplication all over Gajim because it is not sure 221 if we receive a proper contact or just None. 222 223 It is a long way to cleanup this API. Therefore just stick with it 224 and use it as before. We will try to figure out a migration path. 225 """

226 - def __init__(self):

227 self._metacontact_manager = MetacontactManager(self) 228 self._accounts = {}

229

230 - def change_account_name(self, old_name, new_name):

231 self._accounts[new_name] = self._accounts[old_name] 232 self._accounts[new_name].name = new_name 233 del self._accounts[old_name] 234 235 self._metacontact_manager.change_account_name(old_name, new_name)

236

237 - def add_account(self, account_name):

238 self._accounts[account_name] = Account(account_name, Contacts(), 239 GC_Contacts()) 240 self._metacontact_manager.add_account(account_name)

241

242 - def get_accounts(self):

243 return self._accounts.keys()

244

245 - def remove_account(self, account):

246 del self._accounts[account] 247 self._metacontact_manager.remove_account(account)

248

249 - def create_contact(self, jid, account, name='', groups=[], show='', 250 status='', sub='', ask='', resource='', priority=0, keyID='', 251 client_caps=None, our_chatstate=None, chatstate=None, last_status_time=None, 252 composing_xep=None, last_activity_time=None):

253 # Use Account object if available 254 account = self._accounts.get(account, account) 255 return Contact(jid=jid, account=account, name=name, groups=groups, 256 show=show, status=status, sub=sub, ask=ask, resource=resource, 257 priority=priority, keyID=keyID, client_caps=client_caps, 258 our_chatstate=our_chatstate, chatstate=chatstate, 259 last_status_time=last_status_time, composing_xep=composing_xep, 260 last_activity_time=last_activity_time)

261

262 - def create_self_contact(self, jid, account, resource, show, status, priority, 263 name='', keyID=''):

264 conn = common.gajim.connections[account] 265 nick = name or common.gajim.nicks[account] 266 account = self._accounts.get(account, account) # Use Account object if available 267 self_contact = self.create_contact(jid=jid, account=account, 268 name=nick, groups=['self_contact'], show=show, status=status, 269 sub='both', ask='none', priority=priority, keyID=keyID, 270 resource=resource) 271 self_contact.pep = conn.pep 272 return self_contact

273

274 - def create_not_in_roster_contact(self, jid, account, resource='', name='', keyID=''):

275 account = self._accounts.get(account, account) # Use Account object if available 276 return self.create_contact(jid=jid, account=account, resource=resource, 277 name=name, groups=[_('Not in Roster')], show='not in roster', 278 status='', sub='none', keyID=keyID)

279

280 - def copy_contact(self, contact):

281 return self.create_contact(contact.jid, contact.account, 282 name=contact.name, groups=contact.groups, show=contact.show, 283 status=contact.status, sub=contact.sub, ask=contact.ask, 284 resource=contact.resource, priority=contact.priority, 285 keyID=contact.keyID, client_caps=contact.client_caps, 286 our_chatstate=contact.our_chatstate, chatstate=contact.chatstate, 287 last_status_time=contact.last_status_time, 288 composing_xep=contact.composing_xep, 289 last_activity_time=contact.last_activity_time)

290

291 - def add_contact(self, account, contact):

292 if account not in self._accounts: 293 self.add_account(account) 294 return self._accounts[account].contacts.add_contact(contact)

295

296 - def remove_contact(self, account, contact):

297 if account not in self._accounts: 298 return 299 return self._accounts[account].contacts.remove_contact(contact)

300

301 - def remove_jid(self, account, jid, remove_meta=True):

302 self._accounts[account].contacts.remove_jid(jid) 303 if remove_meta: 304 self._metacontact_manager.remove_metacontact(account, jid)

305

306 - def get_contacts(self, account, jid):

307 return self._accounts[account].contacts.get_contacts(jid)

308

309 - def get_contact(self, account, jid, resource=None):

310 return self._accounts[account].contacts.get_contact(jid, resource=resource)

311

312 - def iter_contacts(self, account):

313 for contact in self._accounts[account].contacts.iter_contacts(): 314 yield contact

315

316 - def get_contact_from_full_jid(self, account, fjid):

317 return self._accounts[account].contacts.get_contact_from_full_jid(fjid)

318

319 - def get_first_contact_from_jid(self, account, jid):

320 return self._accounts[account].contacts.get_first_contact_from_jid(jid)

321

322 - def get_contacts_from_group(self, account, group):

323 return self._accounts[account].contacts.get_contacts_from_group(group)

324

325 - def get_contacts_jid_list(self, account):

326 return self._accounts[account].contacts.get_contacts_jid_list()

327

328 - def get_jid_list(self, account):

329 return self._accounts[account].contacts.get_jid_list()

330

331 - def change_contact_jid(self, old_jid, new_jid, account):

332 return self._accounts[account].change_contact_jid(old_jid, new_jid)

333

334 - def get_highest_prio_contact_from_contacts(self, contacts):

335 if not contacts: 336 return None 337 prim_contact = contacts[0] 338 for contact in contacts[1:]: 339 if int(contact.priority) > int(prim_contact.priority): 340 prim_contact = contact 341 return prim_contact

342

343 - def get_contact_with_highest_priority(self, account, jid):

344 contacts = self.get_contacts(account, jid) 345 if not contacts and '/' in jid: 346 # jid may be a fake jid, try it 347 room, nick = jid.split('/', 1) 348 contact = self.get_gc_contact(account, room, nick) 349 return contact 350 return self.get_highest_prio_contact_from_contacts(contacts)

351

352 - def get_nb_online_total_contacts(self, accounts=[], groups=[]):

353 """ 354 Return the number of online contacts and the total number of contacts 355 """ 356 if accounts == []: 357 accounts = self.get_accounts() 358 nbr_online = 0 359 nbr_total = 0 360 for account in accounts: 361 our_jid = common.gajim.get_jid_from_account(account) 362 for jid in self.get_jid_list(account): 363 if jid == our_jid: 364 continue 365 if common.gajim.jid_is_transport(jid) and not \ 366 _('Transports') in groups: 367 # do not count transports 368 continue 369 if self.has_brother(account, jid, accounts) and not \ 370 self.is_big_brother(account, jid, accounts): 371 # count metacontacts only once 372 continue 373 contact = self.get_contact_with_highest_priority(account, jid) 374 if _('Not in roster') in contact.groups: 375 continue 376 in_groups = False 377 if groups == []: 378 in_groups = True 379 else: 380 for group in groups: 381 if group in contact.get_shown_groups(): 382 in_groups = True 383 break 384 385 if in_groups: 386 if contact.show not in ('offline', 'error'): 387 nbr_online += 1 388 nbr_total += 1 389 return nbr_online, nbr_total

390

391 - def __getattr__(self, attr_name):

392 # Only called if self has no attr_name 393 if hasattr(self._metacontact_manager, attr_name): 394 return getattr(self._metacontact_manager, attr_name) 395 else: 396 raise AttributeError(attr_name)

397

398 - def create_gc_contact(self, room_jid, account, name='', show='', status='', 399 role='', affiliation='', jid='', resource=''):

400 account = self._accounts.get(account, account) # Use Account object if available 401 return GC_Contact(room_jid, account, name, show, status, role, affiliation, jid, 402 resource)

403

404 - def add_gc_contact(self, account, gc_contact):

405 return self._accounts[account].gc_contacts.add_gc_contact(gc_contact)

406

407 - def remove_gc_contact(self, account, gc_contact):

408 return self._accounts[account].gc_contacts.remove_gc_contact(gc_contact)

409

410 - def remove_room(self, account, room_jid):

411 return self._accounts[account].gc_contacts.remove_room(room_jid)

412

413 - def get_gc_list(self, account):

414 return self._accounts[account].gc_contacts.get_gc_list()

415

416 - def get_nick_list(self, account, room_jid):

417 return self._accounts[account].gc_contacts.get_nick_list(room_jid)

418

419 - def get_gc_contact(self, account, room_jid, nick):

420 return self._accounts[account].gc_contacts.get_gc_contact(room_jid, nick)

421

422 - def get_nb_role_total_gc_contacts(self, account, room_jid, role):

423 return self._accounts[account].gc_contacts.get_nb_role_total_gc_contacts(room_jid, role)

424 425

426 -class Contacts():

427 """ 428 This is a breakout of the contact related behavior of the old 429 Contacts class (which is not called LegacyContactsAPI) 430 """

431 - def __init__(self):

432 # list of contacts {jid1: [C1, C2]}, } one Contact per resource 433 self._contacts = {}

434

435 - def add_contact(self, contact):

436 if contact.jid not in self._contacts: 437 self._contacts[contact.jid] = [contact] 438 return 439 contacts = self._contacts[contact.jid] 440 # We had only one that was offline, remove it 441 if len(contacts) == 1 and contacts[0].show == 'offline': 442 # Do not use self.remove_contact: it deteles 443 # self._contacts[account][contact.jid] 444 contacts.remove(contacts[0]) 445 # If same JID with same resource already exists, use the new one 446 for c in contacts: 447 if c.resource == contact.resource: 448 self.remove_contact(c) 449 break 450 contacts.append(contact)

451

452 - def remove_contact(self, contact):

453 if contact.jid not in self._contacts: 454 return 455 if contact in self._contacts[contact.jid]: 456 self._contacts[contact.jid].remove(contact) 457 if len(self._contacts[contact.jid]) == 0: 458 del self._contacts[contact.jid]

459

460 - def remove_jid(self, jid):

461 """ 462 Remove all contacts for a given jid 463 """ 464 if jid in self._contacts: 465 del self._contacts[jid]

466

467 - def get_contacts(self, jid):

468 """ 469 Return the list of contact instances for this jid 470 """ 471 return self._contacts.get(jid, [])

472

473 - def get_contact(self, jid, resource=None):

474 ### WARNING ### 475 # This function returns a *RANDOM* resource if resource = None! 476 # Do *NOT* use if you need to get the contact to which you 477 # send a message for example, as a bare JID in Jabber means 478 # highest available resource, which this function ignores! 479 """ 480 Return the contact instance for the given resource if it's given else the 481 first contact is no resource is given or None if there is not 482 """ 483 if jid in self._contacts: 484 if not resource: 485 return self._contacts[jid][0] 486 for c in self._contacts[jid]: 487 if c.resource == resource: 488 return c

489

490 - def iter_contacts(self):

491 for jid in self._contacts.keys(): 492 for contact in self._contacts[jid][:]: 493 yield contact

494

495 - def get_jid_list(self):

496 return self._contacts.keys()

497

498 - def get_contacts_jid_list(self):

499 return [jid for jid, contact in self._contacts.iteritems() if not 500 contact[0].is_groupchat()]

501

502 - def get_contact_from_full_jid(self, fjid):

503 """ 504 Get Contact object for specific resource of given jid 505 """ 506 barejid, resource = common.gajim.get_room_and_nick_from_fjid(fjid) 507 return self.get_contact(barejid, resource)

508

509 - def get_first_contact_from_jid(self, jid):

510 if jid in self._contacts: 511 return self._contacts[jid][0]

512

513 - def get_contacts_from_group(self, group):

514 """ 515 Return all contacts in the given group 516 """ 517 group_contacts = [] 518 for jid in self._contacts: 519 contacts = self.get_contacts(jid) 520 if group in contacts[0].groups: 521 group_contacts += contacts 522 return group_contacts

523

524 - def change_contact_jid(self, old_jid, new_jid):

525 if old_jid not in self._contacts: 526 return 527 self._contacts[new_jid] = [] 528 for _contact in self._contacts[old_jid]: 529 _contact.jid = new_jid 530 self._contacts[new_jid].append(_contact) 531 del self._contacts[old_jid]

532 533

534 -class GC_Contacts():

535

536 - def __init__(self):

537 # list of contacts that are in gc {room_jid: {nick: C}}} 538 self._rooms = {}

539

540 - def add_gc_contact(self, gc_contact):

541 if gc_contact.room_jid not in self._rooms: 542 self._rooms[gc_contact.room_jid] = {gc_contact.name: gc_contact} 543 else: 544 self._rooms[gc_contact.room_jid][gc_contact.name] = gc_contact

545

546 - def remove_gc_contact(self, gc_contact):

547 if gc_contact.room_jid not in self._rooms: 548 return 549 if gc_contact.name not in self._rooms[gc_contact.room_jid]: 550 return 551 del self._rooms[gc_contact.room_jid][gc_contact.name] 552 # It was the last nick in room ? 553 if not len(self._rooms[gc_contact.room_jid]): 554 del self._rooms[gc_contact.room_jid]

555

556 - def remove_room(self, room_jid):

557 if room_jid in self._rooms: 558 del self._rooms[room_jid]

559

560 - def get_gc_list(self):

561 return self._rooms.keys()

562

563 - def get_nick_list(self, room_jid):

564 gc_list = self.get_gc_list() 565 if not room_jid in gc_list: 566 return [] 567 return self._rooms[room_jid].keys()

568

569 - def get_gc_contact(self, room_jid, nick):

570 nick_list = self.get_nick_list(room_jid) 571 if not nick in nick_list: 572 return None 573 return self._rooms[room_jid][nick]

574

575 - def get_nb_role_total_gc_contacts(self, room_jid, role):

576 """ 577 Return the number of group chat contacts for the given role and the total 578 number of group chat contacts 579 """ 580 if room_jid not in self._rooms: 581 return 0, 0 582 nb_role = nb_total = 0 583 for nick in self._rooms[room_jid]: 584 if self._rooms[room_jid][nick].role == role: 585 nb_role += 1 586 nb_total += 1 587 return nb_role, nb_total

588 589

590 -class MetacontactManager():

591

592 - def __init__(self, contacts):

593 self._metacontacts_tags = {} 594 self._contacts = contacts

595

596 - def change_account_name(self, old_name, new_name):

597 self._metacontacts_tags[new_name] = self._metacontacts_tags[old_name] 598 del self._metacontacts_tags[old_name]

599

600 - def add_account(self, account):

601 if account not in self._metacontacts_tags: 602 self._metacontacts_tags[account] = {}

603

604 - def remove_account(self, account):

605 del self._metacontacts_tags[account]

606

607 - def define_metacontacts(self, account, tags_list):

608 self._metacontacts_tags[account] = tags_list

609

610 - def _get_new_metacontacts_tag(self, jid):

611 if not jid in self._metacontacts_tags: 612 return jid 613 #FIXME: can this append ? 614 assert False

615

616 - def iter_metacontacts_families(self, account):

617 for tag in self._metacontacts_tags[account]: 618 family = self._get_metacontacts_family_from_tag(account, tag) 619 yield family

620

621 - def _get_metacontacts_tag(self, account, jid):

622 """ 623 Return the tag of a jid 624 """ 625 if not account in self._metacontacts_tags: 626 return None 627 for tag in self._metacontacts_tags[account]: 628 for data in self._metacontacts_tags[account][tag]: 629 if data['jid'] == jid: 630 return tag 631 return None

632

633 - def add_metacontact(self, brother_account, brother_jid, account, jid, order=None):

634 tag = self._get_metacontacts_tag(brother_account, brother_jid) 635 if not tag: 636 tag = self._get_new_metacontacts_tag(brother_jid) 637 self._metacontacts_tags[brother_account][tag] = [{'jid': brother_jid, 638 'tag': tag}] 639 if brother_account != account: 640 common.gajim.connections[brother_account].store_metacontacts( 641 self._metacontacts_tags[brother_account]) 642 # be sure jid has no other tag 643 old_tag = self._get_metacontacts_tag(account, jid) 644 while old_tag: 645 self.remove_metacontact(account, jid) 646 old_tag = self._get_metacontacts_tag(account, jid) 647 if tag not in self._metacontacts_tags[account]: 648 self._metacontacts_tags[account][tag] = [{'jid': jid, 'tag': tag}] 649 else: 650 if order: 651 self._metacontacts_tags[account][tag].append({'jid': jid, 652 'tag': tag, 'order': order}) 653 else: 654 self._metacontacts_tags[account][tag].append({'jid': jid, 655 'tag': tag}) 656 common.gajim.connections[account].store_metacontacts( 657 self._metacontacts_tags[account])

658

659 - def remove_metacontact(self, account, jid):

660 if not account in self._metacontacts_tags: 661 return 662 663 found = None 664 for tag in self._metacontacts_tags[account]: 665 for data in self._metacontacts_tags[account][tag]: 666 if data['jid'] == jid: 667 found = data 668 break 669 if found: 670 self._metacontacts_tags[account][tag].remove(found) 671 common.gajim.connections[account].store_metacontacts( 672 self._metacontacts_tags[account]) 673 break

674

675 - def has_brother(self, account, jid, accounts):

676 tag = self._get_metacontacts_tag(account, jid) 677 if not tag: 678 return False 679 meta_jids = self._get_metacontacts_jids(tag, accounts) 680 return len(meta_jids) > 1 or len(meta_jids[account]) > 1

681

682 - def is_big_brother(self, account, jid, accounts):

683 family = self.get_metacontacts_family(account, jid) 684 if family: 685 nearby_family = [data for data in family 686 if account in accounts] 687 bb_data = self._get_metacontacts_big_brother(nearby_family) 688 if bb_data['jid'] == jid and bb_data['account'] == account: 689 return True 690 return False

691

692 - def _get_metacontacts_jids(self, tag, accounts):

693 """ 694 Return all jid for the given tag in the form {acct: [jid1, jid2],.} 695 """ 696 answers = {} 697 for account in self._metacontacts_tags: 698 if tag in self._metacontacts_tags[account]: 699 if account not in accounts: 700 continue 701 answers[account] = [] 702 for data in self._metacontacts_tags[account][tag]: 703 answers[account].append(data['jid']) 704 return answers

705

706 - def get_metacontacts_family(self, account, jid):

707 """ 708 Return the family of the given jid, including jid in the form: 709 [{'account': acct, 'jid': jid, 'order': order}, ] 'order' is optional 710 """ 711 tag = self._get_metacontacts_tag(account, jid) 712 return self._get_metacontacts_family_from_tag(account, tag)

713

714 - def _get_metacontacts_family_from_tag(self, account, tag):

715 if not tag: 716 return [] 717 answers = [] 718 for account in self._metacontacts_tags: 719 if tag in self._metacontacts_tags[account]: 720 for data in self._metacontacts_tags[account][tag]: 721 data['account'] = account 722 answers.append(data) 723 return answers

724

725 - def _compare_metacontacts(self, data1, data2):

726 """ 727 Compare 2 metacontacts 728 729 Data is {'jid': jid, 'account': account, 'order': order} order is 730 optional 731 """ 732 jid1 = data1['jid'] 733 jid2 = data2['jid'] 734 account1 = data1['account'] 735 account2 = data2['account'] 736 contact1 = self._contacts.get_contact_with_highest_priority(account1, jid1) 737 contact2 = self._contacts.get_contact_with_highest_priority(account2, jid2) 738 show_list = ['not in roster', 'error', 'offline', 'invisible', 'dnd', 739 'xa', 'away', 'chat', 'online', 'requested', 'message'] 740 # contact can be null when a jid listed in the metacontact data 741 # is not in our roster 742 if not contact1: 743 if contact2: 744 return -1 # prefer the known contact 745 else: 746 show1 = 0 747 priority1 = 0 748 else: 749 show1 = show_list.index(contact1.show) 750 priority1 = contact1.priority 751 if not contact2: 752 if contact1: 753 return 1 # prefer the known contact 754 else: 755 show2 = 0 756 priority2 = 0 757 else: 758 show2 = show_list.index(contact2.show) 759 priority2 = contact2.priority 760 # If only one is offline, it's always second 761 if show1 > 2 and show2 < 3: 762 return 1 763 if show2 > 2 and show1 < 3: 764 return -1 765 if 'order' in data1 and 'order' in data2: 766 if data1['order'] > data2['order']: 767 return 1 768 if data1['order'] < data2['order']: 769 return -1 770 if 'order' in data1: 771 return 1 772 if 'order' in data2: 773 return -1 774 transport1 = common.gajim.get_transport_name_from_jid(jid1) 775 transport2 = common.gajim.get_transport_name_from_jid(jid2) 776 if transport2 and not transport1: 777 return 1 778 if transport1 and not transport2: 779 return -1 780 if show1 > show2: 781 return 1 782 if show2 > show1: 783 return -1 784 if priority1 > priority2: 785 return 1 786 if priority2 > priority1: 787 return -1 788 server1 = common.gajim.get_server_from_jid(jid1) 789 server2 = common.gajim.get_server_from_jid(jid2) 790 myserver1 = common.gajim.config.get_per('accounts', account1, 'hostname') 791 myserver2 = common.gajim.config.get_per('accounts', account2, 'hostname') 792 if server1 == myserver1: 793 if server2 != myserver2: 794 return 1 795 elif server2 == myserver2: 796 return -1 797 if jid1 > jid2: 798 return 1 799 if jid2 > jid1: 800 return -1 801 # If all is the same, compare accounts, they can't be the same 802 if account1 > account2: 803 return 1 804 if account2 > account1: 805 return -1 806 return 0

807

808 - def get_nearby_family_and_big_brother(self, family, account):

809 """ 810 Return the nearby family and its Big Brother 811 812 Nearby family is the part of the family that is grouped with the 813 metacontact. A metacontact may be over different accounts. If accounts 814 are not merged then the given family is split account wise. 815 816 (nearby_family, big_brother_jid, big_brother_account) 817 """ 818 if common.gajim.config.get('mergeaccounts'): 819 # group all together 820 nearby_family = family 821 else: 822 # we want one nearby_family per account 823 nearby_family = [data for data in family if account == data['account']] 824 825 big_brother_data = self._get_metacontacts_big_brother(nearby_family) 826 big_brother_jid = big_brother_data['jid'] 827 big_brother_account = big_brother_data['account'] 828 829 return (nearby_family, big_brother_jid, big_brother_account)

830

831 - def _get_metacontacts_big_brother(self, family):

832 """ 833 Which of the family will be the big brother under wich all others will be 834 ? 835 """ 836 family.sort(cmp=self._compare_metacontacts) 837 return family[-1]

838

Source Code for Module common.contacts