mygpo/db/couchdb/user.py

   1 from collections import Counter
   2
   3 from couchdbkit import ResourceNotFound
   4
   5 from mygpo.cache import cache_result
   6 from mygpo.decorators import repeat_on_conflict
   7 from mygpo.db.couchdb import get_main_database
   8 from mygpo.users.settings import FLATTR_TOKEN, FLATTR_AUTO, FLATTR_MYGPO, \
   9          FLATTR_USERNAME
  10 from mygpo.db import QueryParameterMissing
  11 from mygpo.db.couchdb.episode import episodes_by_id
  12
  13
  14 @cache_result(timeout=60)
  15 def get_num_listened_episodes(user):
  16
  17     if not user:
  18         raise QueryParameterMissing('user')
  19
  20     db = get_main_database()
  21     r = db.view('listeners/by_user_podcast',
  22             startkey    = [user._id, None],
  23             endkey      = [user._id, {}],
  24             reduce      = True,
  25             group_level = 2,
  26             stale       = 'update_after',
  27         )
  28
  29     return map(_wrap_num_listened, r)
  30
  31
  32 def _wrap_num_listened(obj):
  33     count = obj['value']
  34     podcast = obj['key'][1]
  35     return (podcast, count)
  36
  37
  38 @cache_result(timeout=60)
  39 def get_num_played_episodes(user, since=None, until={}):
  40     """ Number of played episodes in interval """
  41
  42     if not user:
  43         raise QueryParameterMissing('user')
  44
  45     since_str = since.strftime('%Y-%m-%d') if since else None
  46     until_str = until.strftime('%Y-%m-%d') if until else {}
  47
  48     startkey = [user._id, since_str]
  49     endkey   = [user._id, until_str]
  50
  51     db = get_main_database()
  52     res = db.view('listeners/by_user',
  53             startkey = startkey,
  54             endkey   = endkey,
  55             reduce   = True,
  56             stale    = 'update_after',
  57         )
  58
  59     val = res.one()
  60     return val['value'] if val else 0
  61
  62
  63
  64
  65 @cache_result(timeout=60)
  66 def get_latest_episodes(user, count=10):
  67     """ Returns the latest episodes that the user has accessed """
  68
  69     if not user:
  70         raise QueryParameterMissing('user')
  71
  72     startkey = [user._id, {}]
  73     endkey   = [user._id, None]
  74
  75     db = get_main_database()
  76     res = db.view('listeners/by_user',
  77             startkey     = startkey,
  78             endkey       = endkey,
  79             include_docs = True,
  80             descending   = True,
  81             limit        = count,
  82             reduce       = False,
  83             stale        = 'update_after',
  84         )
  85
  86     keys = [r['value'] for r in res]
  87     return episodes_by_id(keys)
  88
  89
  90
  91 @cache_result(timeout=60)
  92 def get_seconds_played(user, since=None, until={}):
  93     """ Returns the number of seconds that the user has listened
  94
  95     Can be selected by timespan, podcast and episode """
  96
  97     if not user:
  98         raise QueryParameterMissing('user')
  99
 100     since_str = since.strftime('%Y-%m-%dT%H:%M:%S') if since else None
 101     until_str = until.strftime('%Y-%m-%dT%H:%M:%S') if until else {}
 102
 103     startkey = [user._id, since_str]
 104     endkey   = [user._id, until_str]
 105
 106     db = get_main_database()
 107     res = db.view('listeners/times_played_by_user',
 108             startkey = startkey,
 109             endkey   = endkey,
 110             reduce   = True,
 111             stale    = 'update_after',
 112         )
 113
 114     val = res.one()
 115     return val['value'] if val else 0
 116
 117
 118
 119 @cache_result(timeout=60*60)
 120 def suggestions_for_user(user):
 121
 122     if not user:
 123         raise QueryParameterMissing('user')
 124
 125     from mygpo.users.models import Suggestions
 126     r = Suggestions.view('suggestions/by_user',
 127                 key          = user._id,
 128                 include_docs = True,
 129             )
 130
 131     if r:
 132         return r.first()
 133
 134     else:
 135         s = Suggestions()
 136         s.user = user._id
 137         return s
 138
 139
 140 @cache_result(timeout=60*60)
 141 def user_agent_stats():
 142     from mygpo.users.models import User
 143     res = User.view('clients/by_ua_string',
 144         wrap_doc    = False,
 145         group_level = 1,
 146         stale       = 'update_after',
 147     )
 148
 149     return Counter(dict((r['key'], r['value']) for r in res))
 150
 151
 152 def deleted_users():
 153     from mygpo.users.models import User
 154     users = User.view('users/deleted',
 155             include_docs = True,
 156             reduce       = False,
 157         )
 158     return list(users)
 159
 160
 161 def deleted_user_count():
 162     from mygpo.users.models import User
 163     total = User.view('users/deleted',
 164             reduce = True,
 165         )
 166     return list(total)[0]['value'] if total else 0
 167
 168
 169
 170 @cache_result(timeout=60)
 171 def user_history(user, start, length):
 172
 173     if not user:
 174         raise QueryParameterMissing('user')
 175
 176     if length <= 0:
 177         return []
 178
 179     db = get_main_database()
 180     res = db.view('history/by_user',
 181             descending = True,
 182             startkey   = [user._id, {}],
 183             endkey     = [user._id, None],
 184             limit      = length,
 185             skip       = start,
 186         )
 187
 188     return map(_wrap_historyentry, res)
 189
 190
 191 @cache_result(timeout=60)
 192 def device_history(user, device, start, length):
 193
 194     if not user:
 195         raise QueryParameterMissing('user')
 196
 197     if not device:
 198         raise QueryParameterMissing('device')
 199
 200     if length <= 0:
 201         return []
 202
 203     db = get_main_database()
 204
 205     res = db.view('history/by_device',
 206             descending = True,
 207             startkey   = [user._id, device.id, {}],
 208             endkey     = [user._id, device.id, None],
 209             limit      = length,
 210             skip       = start,
 211         )
 212
 213     return map(_wrap_historyentry, res)
 214
 215
 216 @repeat_on_conflict(['user'])
 217 def update_flattr_settings(user, token, enabled=None, flattr_mygpo=False,
 218         username=None):
 219     """ Updates the Flattr settings of a user """
 220
 221     if enabled is not None:
 222         user.settings[FLATTR_AUTO.name] = enabled
 223
 224     if token is not None:
 225         user.settings[FLATTR_TOKEN.name] = token
 226
 227     if flattr_mygpo is not None:
 228         user.settings[FLATTR_MYGPO.name] = flattr_mygpo
 229
 230     if username is not None:
 231         user.settings[FLATTR_USERNAME.name] = username
 232
 233     user.save()
 234
 235
 236 def _wrap_historyentry(action):
 237     from mygpo.users.models import HistoryEntry
 238     return HistoryEntry.from_action_dict(action['value'])
 239
 240
 241 def user_by_google_email(email):
 242     """ Get a user by its connected Google account """
 243
 244     from mygpo.users.models import User
 245     users = User.view('users/by_google_email',
 246             key          = email,
 247             include_docs = True,
 248         )
 249
 250     if not users:
 251         return None
 252
 253     return users.one()
 254
 255
 256 @repeat_on_conflict(['user'])
 257 def set_users_google_email(user, email):
 258     """ Update the Google accoutn connected with the user """
 259
 260     if user.google_email == email:
 261         return user
 262
 263     user.google_email = email
 264     user.save()
 265     return user
 266
 267
 268 def get_user_by_id(user_id):
 269     from mygpo.users.models import User
 270     try:
 271         return User.get(user_id)
 272     except ResourceNotFound:
 273         return None
 274
 275
 276 @repeat_on_conflict(['user'])
 277 def activate_user(user):
 278     """ activates a user so that he is able to login """
 279     user.is_active = True
 280     user.activation_key = None
 281     user.save()