roster.py 10.8 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
"""
Defines the Roster and RosterGroup classes
"""
10 11
import logging
log = logging.getLogger(__name__)
12

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

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

mathieui's avatar
mathieui committed
22

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

29
    DEFAULT_FILTER = (lambda x, y: None, None)
mathieui's avatar
mathieui committed
30

31
    def __init__(self):
32
        """
louiz’'s avatar
louiz’ committed
33
        node: the RosterSingle from slixmpp
34 35
        """
        self.__node = None
36 37 38 39

        # A tuple(function, *args) function to filter contacts
        # on search, for example
        self.contact_filter = self.DEFAULT_FILTER
mathieui's avatar
mathieui committed
40 41
        self.folded_groups = set(
            config.get('folded_roster_groups', section='var').split(':'))
42 43
        self.groups = {}
        self.contacts = {}
mathieui's avatar
mathieui committed
44 45
        self.length = 0
        self.connected = 0
46

47 48 49 50 51 52 53 54 55 56 57
        # 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

58 59
    def __getitem__(self, key):
        """Get a Contact from his bare JID"""
60
        key = safeJID(key).bare
61 62 63 64 65 66
        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
67

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

mathieui's avatar
mathieui committed
72 73 74 75 76 77 78 79
    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
80
                log.debug('IqError when removing %s:', jid, exc_info=True)
mathieui's avatar
mathieui committed
81

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

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

96 97 98 99 100 101
    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"""
102
        return safeJID(key).bare in self.jids()
103

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

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

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

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

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
    def get_group(self, name):
        """Return a group or create it if not present"""
        if name in self.groups:
            return self.groups[name]
mathieui's avatar
mathieui committed
139 140
        self.groups[name] = RosterGroup(
            name, folded=name in self.folded_groups)
141 142 143 144 145 146 147

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

    def jids(self):
        """List of the contact JIDS"""
148 149 150 151 152
        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
153
        self.update_size(l)
154
        return l
155

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

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

mathieui's avatar
mathieui committed
167 168 169 170 171 172 173
    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:
174
                if self.contact_filter is not self.DEFAULT_FILTER:
mathieui's avatar
mathieui committed
175 176 177 178 179 180 181 182 183 184 185 186 187 188
                    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

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

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

    def update_contact_groups(self, contact):
        """Regenerate the RosterGroups when receiving a contact update"""
        if not isinstance(contact, Contact):
mathieui's avatar
mathieui committed
208
            contact = self.get_and_set(contact)
209 210 211 212 213 214 215 216 217
        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:
218
            if group not in self.groups:
mathieui's avatar
mathieui committed
219 220
                self.groups[group] = RosterGroup(
                    group, folded=group in self.folded_groups)
221
                self.groups[group].add(contact)
mathieui's avatar
mathieui committed
222

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

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

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

255 256 257 258 259 260 261 262 263
    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


264
class RosterGroup:
265
    """
266 267 268
    A RosterGroup is a group containing contacts
    It can be Friends/Family etc, but also can be
    Online/Offline or whatever
269
    """
mathieui's avatar
mathieui committed
270

mathieui's avatar
mathieui committed
271 272 273
    def __init__(self, name, contacts=None, folded=False):
        if not contacts:
            contacts = []
274
        self.contacts = set(contacts)
275
        self.name = name if name is not None else ''
mathieui's avatar
mathieui committed
276
        self.folded = folded  # if the group content is to be shown
277

278 279 280
    def __iter__(self):
        """Iterate over the contacts"""
        return iter(self.contacts)
281

282 283
    def __repr__(self):
        return '<Roster_group: %s; %s>' % (self.name, self.contacts)
284

285
    def __len__(self):
mathieui's avatar
mathieui committed
286
        """Number of contacts in the group"""
287
        return len(self.contacts)
288

289
    def __contains__(self, contact):
290
        """
291
        Return a bool, telling if the contact is in the group
292
        """
293 294 295 296 297 298 299 300 301 302
        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)
303

304
    def get_contacts(self, contact_filter=None, sort=''):
305
        """Return the group contacts, filtered and sorted"""
306 307 308
        if contact_filter is Roster.DEFAULT_FILTER or contact_filter is None:
            contact_list = self.contacts.copy()
        else:
mathieui's avatar
mathieui committed
309 310 311
            contact_list = [
                contact for contact in self.contacts.copy()
                if contact_filter[0](contact, contact_filter[1])
312
            ]
313
        contact_list = sorted(contact_list, key=SORTING_METHODS['name'])
314

315
        for sorting in sort.split(':'):
316 317 318
            if sorting == 'reverse':
                contact_list = list(reversed(contact_list))
            else:
319
                method = SORTING_METHODS.get(sorting, lambda x: 0)
320 321 322
                contact_list = sorted(contact_list, key=method)
        return contact_list

323
    def toggle_folded(self):
mathieui's avatar
mathieui committed
324
        """Fold/unfold the group in the roster"""
325
        self.folded = not self.folded
326 327 328 329 330 331
        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)
332

333
    def get_nb_connected_contacts(self):
mathieui's avatar
mathieui committed
334
        """Return the number of connected contacts"""
335
        return len([1 for contact in self.contacts if len(contact)])
336

mathieui's avatar
mathieui committed
337

338 339 340 341 342
def create_roster():
    "Create the global roster object"
    global roster
    roster = Roster()

mathieui's avatar
mathieui committed
343

mathieui's avatar
mathieui committed
344
# Shared roster object
345
roster = None