common.lib.user

  1"""
  2User class
  3"""
  4import html2text
  5import hashlib
  6import smtplib
  7import socket
  8import bcrypt
  9import json
 10import time
 11import os
 12
 13from email.mime.multipart import MIMEMultipart
 14from email.mime.text import MIMEText
 15
 16from common.config_manager import ConfigWrapper
 17from common.lib.helpers import send_email
 18from common.lib.exceptions import DataSetException
 19
 20
 21class User:
 22    """
 23    User class
 24
 25    Compatible with Flask-Login
 26    """
 27    data = None
 28    userdata = None
 29    is_authenticated = False
 30    is_active = False
 31    is_anonymous = True
 32    config = None
 33    db = None
 34
 35    name = "anonymous"
 36
 37    @staticmethod
 38    def get_by_login(db, name, password, config=None):
 39        """
 40        Get user object, if login is correct
 41
 42        If the login data supplied to this method is correct, a new user object
 43        that is marked as authenticated is returned.
 44
 45        :param db:  Database connection object
 46        :param name:  User name
 47        :param password:  User password
 48        :param config:  Configuration manager. Can be used for request-aware user objects using ConfigWrapper. Empty to
 49        use a global configuration manager.
 50        :return:  User object, or `None` if login was invalid
 51        """
 52        user = db.fetchone("SELECT * FROM users WHERE name = %s", (name,))
 53        if not user or not user.get("password", None):
 54            # registration not finished yet
 55            return None
 56        elif not user or not bcrypt.checkpw(password.encode("ascii"), user["password"].encode("ascii")):
 57            # non-existing user or wrong password
 58            return None
 59        else:
 60            # valid login!
 61            return User(db, user, authenticated=True, config=config)
 62
 63    @staticmethod
 64    def get_by_name(db, name, config=None):
 65        """
 66        Get user object for given user name
 67
 68        :param db:  Database connection object
 69        :param str name:  Username to get object for
 70        :param config:  Configuration manager. Can be used for request-aware user objects using ConfigWrapper. Empty to
 71        use a global configuration manager.
 72        :return:  User object, or `None` for invalid user name
 73        """
 74        user = db.fetchone("SELECT * FROM users WHERE name = %s", (name,))
 75        if not user:
 76            return None
 77        else:
 78            return User(db, user, config=config)
 79
 80    @staticmethod
 81    def get_by_token(db, token, config=None):
 82        """
 83        Get user object for given token, if token is valid
 84
 85        :param db:  Database connection object
 86        :param str token:  Token to get object for
 87        :param config:  Configuration manager. Can be used for request-aware user objects using ConfigWrapper. Empty to
 88        use a global configuration manager.
 89        :return:  User object, or `None` for invalid token
 90        """
 91        user = db.fetchone(
 92            "SELECT * FROM users WHERE register_token = %s AND (timestamp_token = 0 OR timestamp_token > %s)",
 93            (token, int(time.time()) - (7 * 86400)))
 94        if not user:
 95            return None
 96        else:
 97            return User(db, user, config=config)
 98
 99    def __init__(self, db, data, authenticated=False, config=None):
100        """
101        Instantiate user object
102
103        Also sets the properties required by Flask-Login.
104
105        :param db:  Database connection object
106        :param data:  User data
107        :param authenticated:  Whether the user should be marked as authenticated
108        """
109        self.db = db
110        self.data = data
111
112        try:
113            self.userdata = json.loads(self.data["userdata"])
114        except (TypeError, json.JSONDecodeError):
115            self.userdata = {}
116
117        if self.data["name"] != "anonymous":
118            self.is_anonymous = False
119            self.is_active = True
120
121        self.name = self.data["name"]
122        self.is_authenticated = authenticated
123
124        self.userdata = json.loads(self.data.get("userdata", "{}"))
125
126        if not self.is_anonymous and self.is_authenticated:
127            self.db.update("users", where={"name": self.data["name"]}, data={"timestamp_seen": int(time.time())})
128
129        if config:
130            self.with_config(config)
131
132    def authenticate(self):
133        """
134        Mark user object as authenticated.
135        """
136        self.is_authenticated = True
137
138    def get_id(self):
139        """
140        Get user ID
141
142        :return:  User ID
143        """
144        return self.data["name"]
145
146    def get_name(self):
147        """
148        Get user name
149
150        This is usually the user ID. For the two special users, provide a nicer
151        name to display in interfaces, etc.
152
153        :return: User name
154        """
155        if self.data["name"] == "anonymous":
156            return "Anonymous"
157        elif self.data["name"] == "autologin":
158            return self.config.get("flask.autologin.name") if self.config else "Autologin"
159        else:
160            return self.data["name"]
161
162    def get_token(self):
163        """
164        Get password reset token
165
166        May be empty or invalid!
167
168        :return str: Password reset token
169        """
170        return self.generate_token(regenerate=False)
171
172    def with_config(self, config, rewrap=True):
173        """
174        Connect user to configuration manager
175
176        By default, the user object reads from the global configuration
177        manager. For frontend operations it may be desireable to use a
178        request-aware configuration manager, but this is only available after
179        the user has been instantiated. This method can thus be used to connect
180        the user to that config manager later when it is available.
181
182        :param config:  Configuration manager object
183        :param bool rewrap:  Re-wrap with this user as the user context?
184        :return:
185        """
186        if rewrap:
187            self.config = ConfigWrapper(config, user=self)
188        else:
189            self.config = config
190
191    def clear_token(self):
192        """
193        Reset password rest token
194
195        Clears the token and token timestamp. This allows requesting a new one
196        even if the old one had not expired yet.
197
198        :return:
199        """
200        self.db.update("users", data={"register_token": "", "timestamp_token": 0}, where={"name": self.get_id()})
201
202    def can_access_dataset(self, dataset, role=None):
203        """
204        Check if this user should be able to access a given dataset.
205
206        This depends mostly on the dataset's owner, which should match the
207        user if the dataset is private. If the dataset is not private, or
208        if the user is an admin or the dataset is private but assigned to
209        an anonymous user, the dataset can be accessed.
210
211        :param dataset:  The dataset to check access to
212        :return bool:
213        """
214        if not dataset.is_private:
215            return True
216
217        elif self.is_admin:
218            return True
219        
220        elif self.config.get("privileges.can_view_private_datasets", user=self):
221            # Allowed to see dataset, but perhaps not run processors (need privileges.admin.can_manipulate_all_datasets or dataset ownership)
222            return True
223
224        elif dataset.is_accessible_by(self, role=role):
225            return True
226
227        elif dataset.get_owners == ("anonymous",):
228            return True
229
230        else:
231            return False
232
233    @property
234    def is_special(self):
235        """
236        Check if user is special user
237
238        :return:  Whether the user is the anonymous user, or the automatically
239        logged in user.
240        """
241        return self.get_id() in ("autologin", "anonymous")
242
243    @property
244    def is_admin(self):
245        """
246        Check if user is an administrator
247
248        :return bool:
249        """
250        try:
251            return "admin" in self.data["tags"]
252        except (ValueError, TypeError):
253            # invalid JSON?
254            return False
255
256    @property
257    def is_deactivated(self):
258        """
259        Check if user has been deactivated
260
261        :return bool:
262        """
263        return self.data.get("is_deactivated", False)
264
265    def email_token(self, new=False):
266        """
267        Send user an e-mail with a password reset link
268
269        Generates a token that the user can use to reset their password. The
270        token is valid for 72 hours.
271
272        Note that this requires a mail server to be configured, or a
273        `RuntimeError` will be raised. If a server is configured but the mail
274        still fails to send, it will also raise a `RuntimeError`. Note that
275        in these cases a token is still created and valid (the user just gets
276        no notification, but an admin could forward the correct link).
277
278        If the user is a 'special' user, a `ValueError` is raised.
279
280        :param bool new:  Is this the first time setting a password for this
281                          account?
282        :return str:  Link for the user to set their password with
283        """
284        if not self.config:
285            raise ValueError("User not instantiated with a configuration reader. Provide a ConfigManager at "
286                             "instantiation or use with_config().")
287
288        if not self.config.get('mail.server'):
289            raise RuntimeError("No e-mail server configured. 4CAT cannot send any e-mails.")
290
291        if self.is_special:
292            raise ValueError("Cannot send password reset e-mails for a special user.")
293
294        username = self.get_id()
295
296        # generate a password reset token
297        register_token = self.generate_token(regenerate=True)
298
299        # prepare welcome e-mail
300        sender = self.config.get('mail.noreply')
301        message = MIMEMultipart("alternative")
302        message["From"] = sender
303        message["To"] = username
304
305        # the actual e-mail...
306        url_base = self.config.get("flask.server_name")
307        protocol = "https" if self.config.get("flask.https") else "http"
308        url = "%s://%s/reset-password/?token=%s" % (protocol, url_base, register_token)
309
310        # we use slightly different e-mails depending on whether this is the first time setting a password
311        if new:
312
313            message["Subject"] = "Account created"
314            mail = """
315			<p>Hello %s,</p>
316			<p>A 4CAT account has been created for you. You can now log in to 4CAT at <a href="%s://%s">%s</a>.</p>
317			<p>Note that before you log in, you will need to set a password. You can do so via the following link:</p>
318			<p><a href="%s">%s</a></p> 
319			<p>Please complete your registration within 72 hours as the link above will become invalid after this time.</p>
320			""" % (username, protocol, url_base, url_base, url, url)
321        else:
322
323            message["Subject"] = "Password reset"
324            mail = """
325			<p>Hello %s,</p>
326			<p>Someone has requested a password reset for your 4CAT account. If that someone is you, great! If not, feel free to ignore this e-mail.</p>
327			<p>You can change your password via the following link:</p>
328			<p><a href="%s">%s</a></p> 
329			<p>Please do this within 72 hours as the link above will become invalid after this time.</p>
330			""" % (username, url, url)
331
332        # provide a plain-text alternative as well
333        html_parser = html2text.HTML2Text()
334        message.attach(MIMEText(html_parser.handle(mail), "plain"))
335        message.attach(MIMEText(mail, "html"))
336
337        # try to send it
338        try:
339            send_email([username], message, self.config)
340            return url
341        except (smtplib.SMTPException, ConnectionRefusedError, socket.timeout, socket.gaierror) as e:
342            raise RuntimeError("Could not send password reset e-mail: %s" % e)
343
344    def generate_token(self, username=None, regenerate=True):
345        """
346        Generate and store a new registration token for this user
347
348        Tokens are not re-generated if they exist already
349
350        :param username:  Username to generate for: if left empty, it will be
351        inferred from self.data
352        :param regenerate:  Force regenerating even if token exists
353        :return str:  The token
354        """
355        if self.data.get("register_token", None) and not regenerate:
356            return self.data["register_token"]
357
358        if not username:
359            username = self.data["name"]
360
361        register_token = hashlib.sha256()
362        register_token.update(os.urandom(128))
363        register_token = register_token.hexdigest()
364        self.db.update("users", data={"register_token": register_token, "timestamp_token": int(time.time())},
365                       where={"name": username})
366
367        return register_token
368
369    def get_value(self, key, default=None):
370        """
371        Get persistently stored user property
372
373        :param key:  Name of item to get
374        :param default:  What to return if key is not avaiable (default None)
375        :return:
376        """
377        return self.userdata.get(key, default)
378
379    def set_value(self, key, value):
380        """
381        Set persistently stored user property
382
383        :param key:  Name of item to store
384        :param value:  Value
385        :return:
386        """
387        self.userdata[key] = value
388        self.data["userdata"] = json.dumps(self.userdata)
389
390        self.db.update("users", where={"name": self.get_id()}, data={"userdata": json.dumps(self.userdata)})
391
392    def set_password(self, password):
393        """
394        Set user password
395
396        :param password:  Password to set
397        """
398        if self.is_anonymous:
399            raise Exception("Cannot set password for anonymous user")
400
401        salt = bcrypt.gensalt()
402        password_hash = bcrypt.hashpw(password.encode("ascii"), salt)
403
404        self.db.update("users", where={"name": self.data["name"]}, data={"password": password_hash.decode("utf-8")})
405
406    def add_notification(self, notification, expires=None, allow_dismiss=True):
407        """
408        Add a notification for this user
409
410        Notifications that already exist with the same parameters are not added
411        again.
412
413        :param str notification:  The content of the notification. Can contain
414        Markdown.
415        :param int expires:  Timestamp when the notification should expire. If
416        not provided, the notification does not expire
417        :param bool allow_dismiss:  Whether to allow a user to dismiss the
418        notification.
419        """
420        self.db.insert("users_notifications", {
421            "username": self.get_id(),
422            "notification": notification,
423            "timestamp_expires": expires,
424            "allow_dismiss": allow_dismiss
425        }, safe=True)
426
427    def dismiss_notification(self, notification_id):
428        """
429        Dismiss a notification
430
431        The user can only dismiss notifications they can see!
432
433        :param int notification_id:  ID of the notification to dismiss
434        """
435        current_notifications = [n["id"] for n in self.get_notifications() if n["allow_dismiss"]]
436        if notification_id not in current_notifications:
437            return
438
439        self.db.delete("users_notifications", where={"id": notification_id})
440
441    def get_notifications(self):
442        """
443        Get all notifications for this user
444
445        That is all the user's own notifications, plus those for the groups of
446        users this user belongs to
447
448        :return list:  Notifications, as a list of dictionaries
449        """
450        if not self.config:
451            # User not logged in; only view notifications for everyone
452            tag_recipients = ["!everyone"]
453        else:
454            tag_recipients = ["!everyone", *[f"!{tag}" for tag in self.config.get_active_tags(self)]]
455
456        if self.is_admin:
457            # for backwards compatibility - used to be called '!admins' even if the tag is 'admin'
458            tag_recipients.append("!admins")
459
460        notifications = self.db.fetchall(
461            "SELECT n.* FROM users_notifications AS n, users AS u "
462            "WHERE u.name = %s "
463            "AND (u.name = n.username OR n.username IN %s)", (self.get_id(), tuple(tag_recipients)))
464
465        return notifications
466
467    def add_tag(self, tag):
468        """
469        Add tag to user
470
471        If the tag is already in the tag list, nothing happens.
472
473        :param str tag:  Tag
474        """
475        if tag not in self.data["tags"]:
476            self.data["tags"].append(tag)
477            self.sort_user_tags()
478
479    def remove_tag(self, tag):
480        """
481        Remove tag from user
482
483        If the tag is not part of the tag list, nothing happens.
484
485        :param str tag:  Tag
486        """
487        if tag in self.data["tags"]:
488            self.data["tags"].remove(tag)
489            self.sort_user_tags()
490
491    def sort_user_tags(self):
492        """
493        Ensure user tags are stored in the correct order
494
495        The order of the tags matters, since it decides which one will get to
496        override the global configuration. To avoid having to cross-reference
497        the canonical order every time the tags are queried, we ensure that the
498        tags are stored in the database in the right order to begin with. This
499        method ensures that.
500        """
501        if not self.config:
502            raise ValueError("User not instantiated with a configuration reader. Provide a ConfigManager at "
503                             "instantiation or use with_config().")
504
505        tags = self.data["tags"]
506        sorted_tags = []
507
508        for tag in self.config.get("flask.tag_order"):
509            if tag in tags:
510                sorted_tags.append(tag)
511
512        for tag in tags:
513            if tag not in sorted_tags:
514                sorted_tags.append(tag)
515
516        # whitespace isn't a tag
517        sorted_tags = [tag for tag in sorted_tags if tag.strip()]
518
519        self.data["tags"] = sorted_tags
520        self.db.update("users", where={"name": self.get_id()}, data={"tags": json.dumps(sorted_tags)})
521
522    def delete(self, also_datasets=True):
523        from common.lib.dataset import DataSet
524
525        username = self.data["name"]
526
527        self.db.delete("users_favourites", where={"name": username}, commit=False),
528        self.db.delete("users_notifications", where={"username": username}, commit=False)
529        self.db.delete("access_tokens", where={"name": username}, commit=False)
530
531        # find datasets and delete
532        datasets = self.db.fetchall("SELECT key FROM datasets_owners WHERE name = %s", (username,))
533
534        # delete any datasets and jobs related to deleted datasets
535        if datasets:
536            for dataset in datasets:
537                try:
538                    dataset = DataSet(key=dataset["key"], db=self.db)
539                except DataSetException:
540                    # dataset already deleted?
541                    continue
542
543                if len(dataset.get_owners()) == 1 and also_datasets:
544                    dataset.delete(commit=False)
545                    self.db.delete("jobs", where={"remote_id": dataset.key}, commit=False)
546                else:
547                    dataset.remove_owner(self)
548
549        # and finally the user
550        self.db.delete("users", where={"name": username}, commit=False)
551        self.db.commit()
552
553    def __getattr__(self, attr):
554        """
555        Getter so we don't have to use .data all the time
556
557        :param attr:  Data key to get
558        :return:  Value
559        """
560
561        if attr in dir(self):
562            # an explicitly defined attribute should always be called in favour
563            # of this passthrough
564            attribute = getattr(self, attr)
565            return attribute
566        elif attr in self.data:
567            return self.data[attr]
568        else:
569            raise AttributeError("User object has no attribute %s" % attr)
570
571    def __setattr__(self, attr, value):
572        """
573        Setter so we can flexibly update the database
574
575        Also updates internal data stores (.data etc). If the attribute is
576        unknown, it is stored within the 'userdata' attribute.
577
578        :param str attr:  Attribute to update
579        :param value:  New value
580        """
581
582        # don't override behaviour for *actual* class attributes
583        if attr in dir(self):
584            super().__setattr__(attr, value)
585            return
586
587        if attr not in self.data:
588            self.userdata[attr] = value
589            attr = "userdata"
590            value = self.userdata
591
592        if attr == "userdata":
593            value = json.dumps(value)
594
595        self.db.update("users", where={"name": self.get_id()}, data={attr: value})
596
597        self.data[attr] = value
598
599        if attr == "userdata":
600            self.userdata = json.loads(value)