mygpo/usersettings/models.py

   1 import json
   2
   3 from django.db import models
   4 from django.conf import settings
   5 from django.contrib.contenttypes.models import ContentType
   6 from django.contrib.contenttypes.fields import (GenericRelation,
   7                                                 GenericForeignKey)
   8
   9 from mygpo.users.settings import PUBLIC_SUB_PODCAST
  10 from mygpo.podcasts.models import Podcast
  11
  12 import logging
  13 logger = logging.getLogger(__name__)
  14
  15
  16 class UserSettingsManager(models.Manager):
  17     """ Manager for PodcastConfig objects """
  18
  19     def get_private_podcasts(self, user):
  20         """ Returns the podcasts that the user has marked as private """
  21         settings = self.filter(
  22             user=user,
  23             content_type=ContentType.objects.get_for_model(Podcast),
  24         )
  25
  26         private = []
  27         for setting in settings:
  28             if not setting.get_wksetting(PUBLIC_SUB_PODCAST):
  29                 private.append(setting.content_object)
  30
  31         return private
  32
  33     def get_for_scope(self, user, scope):
  34         """ Returns the settings object for the given user and scope obj
  35
  36         If scope is None, the settings for the user are returned """
  37         if scope is None:
  38             content_type = None
  39             object_id = None
  40         else:
  41             content_type = ContentType.objects.get_for_model(scope)
  42             object_id = scope.pk
  43
  44         try:
  45             return UserSettings.objects.get(
  46                 user=user,
  47                 content_type=content_type,
  48                 object_id=object_id,
  49             )
  50
  51         except UserSettings.DoesNotExist:
  52             # if it does not exist, return a new instance. It is up to the
  53             # caller to save the object if required
  54             return UserSettings(
  55                 user=user,
  56                 content_type=content_type,
  57                 object_id=object_id,
  58             )
  59
  60
  61 class UserSettings(models.Model):
  62     """ Stores settings for a podcast, episode, user or client """
  63
  64     # the user for which the config is stored
  65     user = models.ForeignKey(settings.AUTH_USER_MODEL,
  66                              on_delete=models.CASCADE)
  67
  68     # see https://docs.djangoproject.com/en/1.6/ref/contrib/contenttypes/#generic-relations
  69     content_type = models.ForeignKey(ContentType, null=True, blank=True)
  70     object_id = models.UUIDField(null=True, blank=True)
  71     content_object = GenericForeignKey('content_type', 'object_id')
  72
  73     settings = models.TextField(null=False, default='{}')
  74
  75     class Meta:
  76         unique_together = [
  77             ['user', 'content_type', 'object_id'],
  78         ]
  79
  80         verbose_name_plural = 'User Settings'
  81         verbose_name = 'User Settings'
  82
  83     objects = UserSettingsManager()
  84
  85     def get_wksetting(self, setting):
  86         """ returns the value of a well-known setting """
  87         try:
  88             settings = json.loads(self.settings)
  89         except ValueError as ex:
  90             logger.warn('Decoding settings failed: {msg}'.format(msg=str(ex)))
  91             return None
  92
  93         return settings.get(setting.name, setting.default)
  94
  95     def set_wksetting(self, setting, value):
  96         try:
  97             settings = json.loads(self.settings)
  98         except ValueError as ex:
  99             logger.warn('Decoding settings failed: {msg}'.format(msg=str(ex)))
 100             settings = {}
 101         settings[setting.name] = value
 102         self.settings = json.dumps(settings)
 103
 104     def get_setting(self, name, default):
 105         settings = json.loads(self.settings)
 106         return settings.get(name, default)
 107
 108     def set_setting(self, name, value):
 109         settings = json.loads(self.settings)
 110         settings[name] = value
 111         self.settings = json.dumps(settings)
 112
 113     def del_setting(self, name):
 114         settings = json.loads(self.settings)
 115         try:
 116             settings.pop(name)
 117         except KeyError:
 118             pass
 119         self.settings = json.dumps(settings)
 120
 121     def as_dict(self):
 122         return json.loads(self.settings)