mygpo/db/couchdb/user.py

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