mygpo/db/couchdb/podcast.py

   1 from hashlib import sha1
   2 from datetime import datetime
   3
   4 from restkit import RequestFailed
   5 from couchdbkit import MultipleResultsFound
   6
   7 from django.core.cache import cache
   8
   9 from mygpo.core.models import Podcast, PodcastGroup, PodcastSubscriberData
  10 from mygpo.core.signals import incomplete_obj
  11 from mygpo.decorators import repeat_on_conflict
  12 from mygpo.cache import cache_result
  13 from mygpo.utils import get_timestamp
  14 from mygpo.db.couchdb import get_main_database, get_userdata_database, \
  15     lucene_query
  16 from mygpo.db import QueryParameterMissing
  17 from mygpo.db.couchdb import get_main_database, get_single_result
  18 from mygpo.db.couchdb.utils import multi_request_view, is_couchdb_id
  19
  20 import logging
  21 logger = logging.getLogger(__name__)
  22
  23
  24 def podcast_by_id_uncached(podcast_id, current_id=False):
  25
  26     if not podcast_id:
  27         raise QueryParameterMissing('podcast_id')
  28
  29     db = get_main_database()
  30     podcast = get_single_result(db, 'podcasts/by_id',
  31             key          = podcast_id,
  32             include_docs = True,
  33             wrapper      = _wrap_podcast_group,
  34         )
  35
  36     if not podcast:
  37         return None
  38
  39     if podcast.needs_update:
  40         incomplete_obj.send_robust(sender=podcast)
  41
  42     return podcast
  43
  44
  45 podcast_by_id = cache_result(timeout=60*60)(podcast_by_id_uncached)
  46
  47
  48 def podcasts_by_id(ids):
  49
  50     if ids is None:
  51         raise QueryParameterMissing('ids')
  52
  53     if not ids:
  54         return []
  55
  56     r = Podcast.view('podcasts/by_id',
  57             keys         = ids,
  58             include_docs = True,
  59             wrap_doc     = False
  60         )
  61
  62     podcasts = map(_wrap_podcast_group, r)
  63
  64     for podcast in podcasts:
  65         if podcast.needs_update:
  66             incomplete_obj.send_robust(sender=podcast)
  67
  68     return podcasts
  69
  70
  71 def podcasts_groups_by_id(ids):
  72     """ gets podcast groups and top-level podcasts for the given ids """
  73
  74     if ids is None:
  75         raise QueryParameterMissing('ids')
  76
  77     if not ids:
  78         return
  79
  80     db = get_main_database()
  81     res = db.view('podcasts/podcasts_groups',
  82             keys         = ids,
  83             include_docs = True,
  84         )
  85
  86     for r in res:
  87         obj = _wrap_pg(r)
  88
  89         if not obj:
  90             yield None
  91             continue
  92
  93         if obj.needs_update:
  94             incomplete_obj.send_robust(sender=obj)
  95
  96         yield obj
  97
  98
  99 def _wrap_pg(doc):
 100
 101     doc = doc['doc']
 102
 103     if not doc:
 104         return None
 105
 106     if doc['doc_type'] == 'Podcast':
 107         return Podcast.wrap(doc)
 108
 109     elif doc['doc_type'] == 'PodcastGroup':
 110         return PodcastGroup.wrap(doc)
 111
 112     else:
 113         logger.error('received unknown doc_type "%s"', doc['doc_type'])
 114
 115
 116 def podcasts_to_dict(ids, use_cache=False):
 117
 118     if ids is None:
 119         raise QueryParameterMissing('ids')
 120
 121     if not ids:
 122         return dict()
 123
 124
 125     ids = list(set(ids))
 126     objs = dict()
 127
 128     cache_objs = []
 129     if use_cache:
 130         res = cache.get_many(ids)
 131         cache_objs.extend(res.values())
 132         ids = [x for x in ids if x not in res.keys()]
 133
 134     db_objs = podcasts_by_id(ids)
 135
 136     for obj in (cache_objs + db_objs):
 137
 138         # get_multi returns dict {'key': _id, 'error': 'not found'}
 139         # for non-existing objects
 140         if isinstance(obj, dict) and 'error' in obj:
 141             _id = obj['key']
 142             objs[_id] = None
 143             continue
 144
 145         for i in obj.get_ids():
 146             objs[i] = obj
 147
 148     if use_cache:
 149         cache.set_many(dict( (obj.get_id(), obj) for obj in db_objs))
 150
 151     return objs
 152
 153
 154 def subscriberdata_for_podcast(podcast_id):
 155
 156     if not podcast_id:
 157         raise QueryParameterMissing('podcast_id')
 158
 159     db = get_main_database()
 160     data = get_single_result(db, 'podcasts/subscriber_data',
 161             key          = podcast_id,
 162             include_docs = True,
 163             schema       = PodcastSubscriberData,
 164         )
 165
 166     if not data:
 167         data = PodcastSubscriberData()
 168         data.podcast = podcast_id
 169
 170     return data
 171
 172
 173
 174 def _wrap_podcast_group(res):
 175     if res['doc']['doc_type'] == 'Podcast':
 176         return Podcast.wrap(res['doc'])
 177     else:
 178         pg = PodcastGroup.wrap(res['doc'])
 179         id = res['key']
 180         return pg.get_podcast_by_id(id)
 181
 182
 183 def search_wrapper(result):
 184     doc = result['doc']
 185     if doc['doc_type'] == 'Podcast':
 186         p = Podcast.wrap(doc)
 187     elif doc['doc_type'] == 'PodcastGroup':
 188         p = PodcastGroup.wrap(doc)
 189     p._id = result['id']
 190     return p
 191
 192
 193 @cache_result(timeout=60*60)
 194 def search(q, offset=0, num_results=20):
 195
 196     if not q:
 197         return [], 0
 198
 199     db = get_main_database()
 200
 201     FIELDS = ['title', 'description']
 202     q = lucene_query(FIELDS, q)
 203
 204     try:
 205         res = db.search('podcasts/search',
 206                 wrapper      = search_wrapper,
 207                 include_docs = True,
 208                 limit        = num_results,
 209                 stale        = 'update_after',
 210                 skip         = offset,
 211                 q            = q,
 212             )
 213
 214         podcasts = list(res)
 215
 216         for podcast in podcasts:
 217             if podcast.needs_update:
 218                 incomplete_obj.send_robust(sender=podcast)
 219
 220         return podcasts, res.total_rows
 221
 222     except RequestFailed:
 223         return [], 0
 224
 225
 226 def reload_podcast(podcast):
 227     return podcast_by_id_uncached(podcast.get_id())
 228
 229
 230 @repeat_on_conflict(['podcast'], reload_f=reload_podcast)
 231 def update_additional_data(podcast, twitter):
 232     podcast.twitter = twitter
 233     podcast.save()
 234
 235     # clear the whole cache until we have a better invalidation mechanism
 236     cache.clear()
 237
 238
 239 @repeat_on_conflict(['podcast'], reload_f=reload_podcast)
 240 def update_related_podcasts(podcast, related):
 241     if podcast.related_podcasts == related:
 242         return
 243
 244     podcast.related_podcasts = related
 245     podcast.save()
 246
 247
 248 @repeat_on_conflict(['podcast'], reload_f=reload_podcast)
 249 def delete_podcast(podcast):
 250     podcast.delete()