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     total = User.view('users/deleted',
 157             reduce = True,
 158         )
 159     return list(total)[0]['value'] if total else 0
 160
 161
 162
 163 @cache_result(timeout=60)
 164 def user_history(user, start, length):
 165
 166     if not user:
 167         raise QueryParameterMissing('user')
 168
 169     if length <= 0:
 170         return []
 171
 172     db = get_main_database()
 173     res = db.view('history/by_user',
 174             descending = True,
 175             startkey   = [user._id, {}],
 176             endkey     = [user._id, None],
 177             limit      = length,
 178             skip       = start,
 179         )
 180
 181     return map(_wrap_historyentry, res)
 182
 183
 184 @cache_result(timeout=60)
 185 def device_history(user, device, start, length):
 186
 187     if not user:
 188         raise QueryParameterMissing('user')
 189
 190     if not device:
 191         raise QueryParameterMissing('device')
 192
 193     if length <= 0:
 194         return []
 195
 196     db = get_main_database()
 197
 198     res = db.view('history/by_device',
 199             descending = True,
 200             startkey   = [user._id, device.id, {}],
 201             endkey     = [user._id, device.id, None],
 202             limit      = length,
 203             skip       = start,
 204         )
 205
 206     return map(_wrap_historyentry, res)
 207
 208
 209 @repeat_on_conflict(['user'])
 210 def update_flattr_settings(user, token, enabled=None, flattr_mygpo=False,
 211         username=None):
 212     """ Updates the Flattr settings of a user """
 213
 214     if enabled is not None:
 215         user.settings[FLATTR_AUTO.name] = enabled
 216
 217     if token is not None:
 218         user.settings[FLATTR_TOKEN.name] = token
 219
 220     if flattr_mygpo is not None:
 221         user.settings[FLATTR_MYGPO.name] = flattr_mygpo
 222
 223     if username is not None:
 224         user.settings[FLATTR_USERNAME.name] = username
 225
 226     user.save()
 227
 228
 229 def _wrap_historyentry(action):
 230     from mygpo.users.models import HistoryEntry
 231     return HistoryEntry.from_action_dict(action['value'])
 232
 233
 234 def user_by_google_email(email):
 235     """ Get a user by its connected Google account """
 236
 237     from mygpo.users.models import User
 238     users = User.view('users/by_google_email',
 239             key          = email,
 240             include_docs = True,
 241         )
 242
 243     if not users:
 244         return None
 245
 246     return users.one()
 247
 248
 249 @repeat_on_conflict(['user'])
 250 def set_users_google_email(user, email):
 251     """ Update the Google accoutn connected with the user """
 252
 253     if user.google_email == email:
 254         return user
 255
 256     user.google_email = email
 257     user.save()
 258     return user