roster.py 10.7 KB
Newer Older
louiz’'s avatar
louiz’ committed
1
# Copyright 2010-2011 Florent Le Coz <louiz@louiz.org>
2 3 4 5
#
# This file is part of Poezio.
#
# Poezio is free software: you can redistribute it and/or modify
6
# it under the terms of the zlib license. See the COPYING file.
7

8 9 10 11

"""
Defines the Roster and RosterGroup classes
"""
12 13
import logging
log = logging.getLogger(__name__)
14

mathieui's avatar
mathieui committed
15 16 17
from poezio.config import config
from poezio.contact import Contact
from poezio.roster_sorting import SORTING_METHODS, GROUP_SORTING_METHODS
18 19

from os import path as p
20
from datetime import datetime
mathieui's avatar
mathieui committed
21
from poezio.common import safeJID
louiz’'s avatar
louiz’ committed
22
from slixmpp.exceptions import IqError, IqTimeout
23

24

25
class Roster(object):
mathieui's avatar
mathieui committed
26
    """
louiz’'s avatar
louiz’ committed
27
    The proxy class to get the roster from slixmpp.
28
    Caches Contact and RosterGroup objects.
mathieui's avatar
mathieui committed
29
    """
30

31
    def __init__(self):
32
        """
louiz’'s avatar
louiz’ committed
33
        node: the RosterSingle from slixmpp
34 35 36
        """
        self.__node = None
        self.contact_filter = None # A tuple(function, *args)
37 38
                                    # function to filter contacts,
                                    # on search, for example
39 40
        self.folded_groups = set(config.get('folded_roster_groups',
                                            section='var').split(':'))
41 42
        self.groups = {}
        self.contacts = {}
mathieui's avatar
mathieui committed
43 44
        self.length = 0
        self.connected = 0
45

46 47 48 49 50 51 52 53 54 55 56
        # Used for caching roster infos
        self.last_built = datetime.now()
        self.last_modified = datetime.now()

    def modified(self):
        self.last_modified = datetime.now()

    @property
    def needs_rebuild(self):
        return self.last_modified >= self.last_built

57 58
    def __getitem__(self, key):
        """Get a Contact from his bare JID"""
59
        key = safeJID(key).bare
60 61 62 63 64 65
        if key in self.contacts and self.contacts[key] is not None:
            return self.contacts[key]
        if key in self.jids():
            contact = Contact(self.__node[key])
            self.contacts[key] = contact
            return contact
66

67 68 69
    def __setitem__(self, key, value):
        """Set the a Contact value for the bare jid key"""
        self.contacts[key] = value
70

mathieui's avatar
mathieui committed
71 72 73 74 75 76 77 78
    def remove(self, jid):
        """Send a removal iq to the server"""
        jid = safeJID(jid).bare
        if self.__node[jid]:
            try:
                self.__node[jid].send_presence(ptype='unavailable')
                self.__node.remove(jid)
            except (IqError, IqTimeout):
mathieui's avatar
mathieui committed
79
                log.debug('IqError when removing %s:', jid, exc_info=True)
mathieui's avatar
mathieui committed
80

81
    def __delitem__(self, jid):
mathieui's avatar
mathieui committed
82
        """Remove a contact from the roster view"""
83
        jid = safeJID(jid).bare
84
        contact = self[jid]
mathieui's avatar
mathieui committed
85 86
        if not contact:
            return
mathieui's avatar
mathieui committed
87 88
        del self.contacts[contact.bare_jid]

89 90 91 92
        for group in list(self.groups.values()):
            group.remove(contact)
            if not group:
                del self.groups[group.name]
mathieui's avatar
mathieui committed
93
        self.modified()
94

95 96 97 98 99 100
    def __iter__(self):
        """Iterate over the jids of the contacts"""
        return iter(self.contacts.values())

    def __contains__(self, key):
        """True if the bare jid is in the roster, false otherwise"""
101
        return safeJID(key).bare in self.jids()
102

mathieui's avatar
mathieui committed
103 104 105 106 107
    @property
    def jid(self):
        """Our JID"""
        return self.__node.jid

108
    def get_and_set(self, jid):
mathieui's avatar
mathieui committed
109 110
        contact = self.contacts.get(jid)
        if contact is None:
111 112 113
            contact = Contact(self.__node[jid])
            self.contacts[jid] = contact
            return contact
mathieui's avatar
mathieui committed
114
        return contact
115

mathieui's avatar
mathieui committed
116
    def set_node(self, value):
louiz’'s avatar
louiz’ committed
117
        """Set the slixmpp RosterSingle for our roster"""
mathieui's avatar
mathieui committed
118 119
        self.__node = value

120
    def get_groups(self, sort=''):
mathieui's avatar
mathieui committed
121
        """Return a list of the RosterGroups"""
122
        group_list = sorted(
mathieui's avatar
mathieui committed
123
                (group for group in self.groups.values() if group),
124 125 126
                key=lambda x: x.name.lower() if x.name else ''
            )

127
        for sorting in sort.split(':'):
128 129 130 131 132 133
            if sorting == 'reverse':
                group_list = list(reversed(group_list))
            else:
                method = GROUP_SORTING_METHODS.get(sorting, lambda x: 0)
                group_list = sorted(group_list, key=method)
        return group_list
mathieui's avatar
mathieui committed
134

135 136 137 138 139 140 141 142 143 144 145 146
    def get_group(self, name):
        """Return a group or create it if not present"""
        if name in self.groups:
            return self.groups[name]
        self.groups[name] = RosterGroup(name, folded=name in self.folded_groups)

    def add(self, jid):
        """Subscribe to a jid"""
        self.__node.subscribe(jid)

    def jids(self):
        """List of the contact JIDS"""
147 148 149 150 151
        l = []
        for key in self.__node.keys():
            contact = self.get_and_set(key)
            if key != self.jid and (contact and self.exists(contact)):
                l.append(key)
mathieui's avatar
mathieui committed
152
        self.update_size(l)
153
        return l
154

mathieui's avatar
mathieui committed
155 156 157 158 159
    def update_size(self, jids=None):
        if jids is None:
            jids = self.jids()
        self.length = len(jids)

louiz’'s avatar
louiz’ committed
160 161
    def get_contacts(self):
        """
162
        Return a list of all the contacts
louiz’'s avatar
louiz’ committed
163
        """
164
        return [self[jid] for jid in self.jids()]
louiz’'s avatar
louiz’ committed
165

mathieui's avatar
mathieui committed
166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187
    def get_contacts_sorted_filtered(self, sort=''):
        """
        Return a list of all the contacts sorted with a criteria
        """
        contact_list = []
        for contact in self.get_contacts():
            if contact.bare_jid != self.jid:
                if self.contact_filter:
                    if self.contact_filter[0](contact, self.contact_filter[1]):
                        contact_list.append(contact)
                else:
                    contact_list.append(contact)
        contact_list = sorted(contact_list, key=SORTING_METHODS['name'])

        for sorting in sort.split(':'):
            if sorting == 'reverse':
                contact_list = list(reversed(contact_list))
            else:
                method = SORTING_METHODS.get(sorting, lambda x: 0)
                contact_list = sorted(contact_list, key=method)
        return contact_list

188 189 190 191 192
    def save_to_config_file(self):
        """
        Save various information to the config file
        e.g. the folded groups
        """
193
        folded_groups = ':'.join([group.name for group in self.groups.values()\
194
                                      if group.folded])
mathieui's avatar
mathieui committed
195
        log.debug('folded:%s\n', folded_groups)
mathieui's avatar
mathieui committed
196
        return config.silent_set('folded_roster_groups', folded_groups, 'var')
197

mathieui's avatar
mathieui committed
198
    def get_nb_connected_contacts(self):
mathieui's avatar
mathieui committed
199 200 201
        """
        Get the number of connected contacts
        """
mathieui's avatar
mathieui committed
202
        return self.connected
203 204 205 206

    def update_contact_groups(self, contact):
        """Regenerate the RosterGroups when receiving a contact update"""
        if not isinstance(contact, Contact):
mathieui's avatar
mathieui committed
207
            contact = self.get_and_set(contact)
208 209 210 211 212 213 214 215 216 217 218 219
        if not contact:
            return
        for name, group in self.groups.items():
            if name in contact.groups and contact not in group:
                group.add(contact)
            elif contact in group and name not in contact.groups:
                group.remove(contact)

        for group in contact.groups:
            if not group in self.groups:
                self.groups[group] = RosterGroup(group, folded=group in self.folded_groups)
                self.groups[group].add(contact)
mathieui's avatar
mathieui committed
220

221 222
    def __len__(self):
        """
mathieui's avatar
mathieui committed
223 224 225
        Return the number of contacts
        (used to return the display size, but now we have
        the display cache in RosterWin for that)
226
        """
mathieui's avatar
mathieui committed
227
        return self.length
228 229 230

    def __repr__(self):
        ret = '== Roster:\nContacts:\n'
231
        for contact in self.contacts.values():
232 233
            ret += '%s\n' % (contact,)
        ret += 'Groups\n'
234
        for group in self.groups:
235 236 237
            ret += '%s\n' % (group,)
        return ret + '\n'

238 239 240 241 242
    def export(self, path):
        """Export a list of bare jids to a given file"""
        if p.isfile(path):
            return
        try:
243
            f = open(path, 'w+', encoding='utf-8')
mathieui's avatar
mathieui committed
244
            f.writelines([str(i) + "\n" for i in self.contacts if self[i] and (self[i].subscription == "both" or self[i].ask)])
245 246 247 248
            f.close()
            return True
        except IOError:
            return
mathieui's avatar
mathieui committed
249 250 251
        except OSError:
            return

252 253 254 255 256 257 258 259 260
    def exists(self, contact):
        if not contact:
            return False
        for group in contact.groups:
            if contact not in self.groups.get(group, tuple()):
                return False
        return True


261
class RosterGroup(object):
262
    """
263 264 265
    A RosterGroup is a group containing contacts
    It can be Friends/Family etc, but also can be
    Online/Offline or whatever
266
    """
mathieui's avatar
mathieui committed
267 268 269
    def __init__(self, name, contacts=None, folded=False):
        if not contacts:
            contacts = []
270
        self.contacts = set(contacts)
271
        self.name = name if name is not None else ''
272
        self.folded = folded    # if the group content is to be shown
273

274 275 276
    def __iter__(self):
        """Iterate over the contacts"""
        return iter(self.contacts)
277

278 279
    def __repr__(self):
        return '<Roster_group: %s; %s>' % (self.name, self.contacts)
280

281
    def __len__(self):
mathieui's avatar
mathieui committed
282
        """Number of contacts in the group"""
283
        return len(self.contacts)
284

285
    def __contains__(self, contact):
286
        """
287
        Return a bool, telling if the contact is in the group
288
        """
289 290 291 292 293 294 295 296 297 298
        return contact in self.contacts

    def add(self, contact):
        """Add a contact to the group"""
        self.contacts.add(contact)

    def remove(self, contact):
        """Remove a contact from the group if present"""
        if contact in self.contacts:
            self.contacts.remove(contact)
299

300
    def get_contacts(self, contact_filter=None, sort=''):
301
        """Return the group contacts, filtered and sorted"""
302
        contact_list = self.contacts.copy() if not contact_filter\
mathieui's avatar
mathieui committed
303
            else [contact for contact in self.contacts.copy() if contact_filter[0](contact, contact_filter[1])]
304
        contact_list = sorted(contact_list, key=SORTING_METHODS['name'])
305

306
        for sorting in sort.split(':'):
307 308 309
            if sorting == 'reverse':
                contact_list = list(reversed(contact_list))
            else:
310
                method = SORTING_METHODS.get(sorting, lambda x: 0)
311 312 313
                contact_list = sorted(contact_list, key=method)
        return contact_list

314
    def toggle_folded(self):
mathieui's avatar
mathieui committed
315
        """Fold/unfold the group in the roster"""
316
        self.folded = not self.folded
317 318 319 320 321 322
        if self.folded:
            if self.name not in roster.folded_groups:
                roster.folded_groups.add(self.name)
        else:
            if self.name in roster.folded_groups:
                roster.folded_groups.remove(self.name)
323

324
    def get_nb_connected_contacts(self):
mathieui's avatar
mathieui committed
325
        """Return the number of connected contacts"""
326
        return len([1 for contact in self.contacts if len(contact)])
327

328 329 330 331 332
def create_roster():
    "Create the global roster object"
    global roster
    roster = Roster()

mathieui's avatar
mathieui committed
333
# Shared roster object
334
roster = None