Python models.Podcast类代码示例

    def test_group(self):
        self.podcast1 = Podcast(urls=['http://example1.com'])
        self.podcast1.save()

        self.podcast2 = Podcast(urls=['http://example2.com'])
        self.podcast2.save()

        group = self.podcast1.group_with(self.podcast2, 'My Group', 'p1', 'p2')

        self.assertIn(self.podcast1, group.podcasts)
        self.assertIn(self.podcast2, group.podcasts)
        self.assertEquals(len(group.podcasts), 2)
        self.assertEquals(group.title, 'My Group')
        self.assertEquals(self.podcast1.group_member_name, 'p1')
        self.assertEquals(self.podcast2.group_member_name, 'p2')

        # add to group
        self.podcast3 = Podcast(urls=['http://example3.com'])
        self.podcast3.save()

        group = self.podcast1.group_with(self.podcast3, 'My Group', 'p1', 'p3')

        self.assertIn(self.podcast3, group.podcasts)
        self.assertEquals(self.podcast3.group_member_name, 'p3')

        # add group to podcast
        self.podcast4 = Podcast(urls=['http://example4.com'])
        self.podcast4.save()

        group = self.podcast4.group_with(self.podcast1, 'My Group', 'p4', 'p1')

        self.assertIn(self.podcast4, group.podcasts)
        self.assertEquals(self.podcast4.group_member_name, 'p4')

    def for_podcast(cls, podcast):
        """ all tags for the podcast, in decreasing order of importance """

        res = Podcast.view('tags/by_podcast',
                startkey    = [podcast.get_id(), None],
                endkey      = [podcast.get_id(), {}],
                reduce      = True,
                group       = True,
                group_level = 2,
                stale       = 'update_after',
            )

        tags = Counter(dict((x['key'][1], x['value']) for x in res))

        res = Podcast.view('usertags/by_podcast',
                startkey    = [podcast.get_id(), None],
                endkey      = [podcast.get_id(), {}],
                reduce      = True,
                group       = True,
                group_level = 2,
            )

        tags.update(Counter(dict( (x['key'][1], x['value']) for x in res)))

        get_tag = itemgetter(0)
        return map(get_tag, tags.most_common())

    def setUp(self):
        self.podcast1 = Podcast(urls=['http://example.com/feed.rss'])
        self.podcast2 = Podcast(urls=['http://test.org/podcast/'])
        self.podcast3 = Podcast(urls=['http://test.org/feed/'])
        self.podcast1.save()
        self.podcast2.save()
        self.podcast3.save()

        self.episode1 = Episode(podcast=self.podcast1.get_id(),
                urls = ['http://example.com/episode1.mp3'])
        self.episode2 = Episode(podcast=self.podcast2.get_id(),
                urls = ['http://example.com/episode1.mp3'])
        self.episode3 = Episode(podcast=self.podcast3.get_id(),
                urls = ['http://example.com/media.mp3'])


        self.episode1.save()
        self.episode2.save()
        self.episode3.save()

        self.podcast2.group_with(self.podcast3, 'My Group', 'Feed1', 'Feed2')

        self.user = User(username='test-merge-group')
        self.user.email = '[email protected]'
        self.user.set_password('secret!')
        self.user.save()

def search_podcasts(q, limit=20, skip=0):

    if is_url(q):
        url = sanitize_url(q)

        podcast = Podcast.for_url(url, create=True)

        if not podcast.title:
            update_podcasts([podcast])

        podcast = Podcast.for_url(url)

        return [podcast], 1


    db = get_main_database()

    #FIXME current couchdbkit can't parse responses for multi-query searches
    q = q.replace(',', '')

    res = db.search('podcasts/search', wrapper=search_wrapper,
        include_docs=True, limit=limit, skip=skip, q=q,
        sort='\\subscribers<int>')

    #FIXME: return empty results in case of search backend error
    try:
        return list(res), res.total_rows
    except:
        return [], 0

class MergeTests(TestCase):

    def setUp(self):
        self.podcast1 = Podcast(urls=['http://example.com/feed.rss'])
        self.podcast2 = Podcast(urls=['http://test.org/podcast/'])
        self.podcast1.save()
        self.podcast2.save()

        self.episode1 = Episode(podcast=self.podcast1.get_id(),
                urls = ['http://example.com/episode1.mp3'])
        self.episode2 = Episode(podcast=self.podcast2.get_id(),
                urls = ['http://example.com/episode1.mp3'])

        self.episode1.save()
        self.episode2.save()

        self.user = User(username='test')
        self.user.email = '[email protected]'
        self.user.set_password('secret!')
        self.user.save()


    def test_merge_podcasts(self):

        state1 = self.episode1.get_user_state(self.user)
        state2 = self.episode2.get_user_state(self.user)

        action1 = EpisodeAction(action='play', timestamp=datetime.utcnow())
        action2 = EpisodeAction(action='download', timestamp=datetime.utcnow())

        state1.add_actions([action1])
        state2.add_actions([action2])

        state1.save()
        state2.save()

        pm = PodcastMerger([self.podcast1, self.podcast2])
        pm.merge()

        state1 = self.episode1.get_user_state(self.user)
        state2 = self.episode2.get_user_state(self.user)

        self.assertIn(action1, state1.actions)
        self.assertIn(action2, state1.actions)



    def tearDown(self):
        self.podcast1.delete()
        self.episode1.delete()

        try:
            self.podcast2.delete()
            self.episode2.delete()
        except:
            pass

        self.user.delete()

    def handle(self, *args, **options):

        if len(args) != 5:
            print 'Usage: ./manage.py group-podcasts <url1> <url2> <group-name> <name1> <name2>'
            return

        p1_url = args[0]
        p2_url = args[1]
        group_title = args[2]
        myname = args[3]
        othername = args[4]

        p1 = Podcast.for_url(p1_url)
        p2 = Podcast.for_url(p2_url)

        p1.group_with(p2, group_title, myname, othername)

def add_action(request, episode):

    device = request.user.get_device(request.POST.get('device'))

    action_str = request.POST.get('action')
    timestamp = request.POST.get('timestamp', '')

    if timestamp:
        try:
            timestamp = dateutil.parser.parse(timestamp)
        except:
            timestamp = datetime.utcnow()
    else:
        timestamp = datetime.utcnow()

    action = EpisodeAction()
    action.timestamp = timestamp
    action.device = device.id if device else None
    action.action = action_str

    state = episode.get_user_state(request.user)

    @repeat_on_conflict(['action'])
    def _add_action(action):
        state.add_actions([action])
        state.save()

    _add_action(action=action)

    podcast = Podcast.get(episode.podcast)

    return HttpResponseRedirect(get_episode_link_target(episode, podcast))

def list_favorites(request):
    site = RequestSite(request)

    episodes = backend.get_favorites(request.user)
    podcast_ids = [episode.podcast for episode in episodes]
    podcasts = get_to_dict(Podcast, podcast_ids, Podcast.get_id)

    def set_podcast(episode):
        episode = proxy_object(episode)
        episode.podcast = podcasts.get(episode.podcast, None)
        return episode

    episodes = map(set_podcast, episodes)

    feed_url = 'http://%s/%s' % (site.domain, reverse('favorites-feed', args=[request.user.username]))

    podcast = Podcast.for_url(feed_url)

    if 'public_feed' in request.GET:
        request.user.favorite_feeds_token = ''
        request.user.save()

    elif 'private_feed' in request.GET:
        request.user.create_new_token('favorite_feeds_token', 8)
        request.user.save()

    token = request.user.favorite_feeds_token

    return render(request, 'favorites.html', {
        'episodes': episodes,
        'feed_token': token,
        'site': site,
        'podcast': podcast,
        })

def add_chapter(request, episode):
    e_state = episode.get_user_state(request.user)

    podcast = Podcast.get(episode.podcast)

    try:
        start = parse_time(request.POST.get('start', '0'))

        if request.POST.get('end', '0'):
            end = parse_time(request.POST.get('end', '0'))
        else:
            end = start

        adv = 'advertisement' in request.POST
        label = request.POST.get('label')

    except Exception as e:
        # FIXME: when using Django's messaging system, set error message

        return HttpResponseRedirect(get_episode_link_target(episode, podcast))


    chapter = Chapter()
    chapter.start = start
    chapter.end = end
    chapter.advertisement = adv
    chapter.label = label

    e_state.update_chapters(add=[chapter])

    return HttpResponseRedirect(get_episode_link_target(episode, podcast))

def example_podcasts(request, format):

    podcasts = cache.get('example-podcasts', None)

    try:
        scale = int(request.GET.get('scale_logo', 64))
    except (TypeError, ValueError):
        return HttpResponseBadRequest('scale_logo has to be a numeric value')

    if scale not in range(1, 257):
        return HttpResponseBadRequest('scale_logo has to be a number from 1 to 256')


    if not podcasts:

        try:
            examples = ExamplePodcasts.get('example_podcasts')
            ids = examples.podcast_ids
            podcasts = list(Podcast.get_multi(ids))
            cache.set('example-podcasts', podcasts)

        except ResourceNotFound:
            podcasts = []

    title = 'gPodder Podcast Directory'
    domain = RequestSite(request).domain
    p_data = lambda p: podcast_data(p, domain, scale)
    return format_podcast_list(
            podcasts,
            format,
            title,
            json_map=p_data,
            xml_template='podcasts.xml',
            request=request,
        )

    def _decorator(request, slug_id, *args, **kwargs):
        podcast = Podcast.for_slug_id(slug_id)

        if podcast is None:
            raise Http404

        return f(request, podcast, *args, **kwargs)

def get_episode_link_target(episode, podcast, view_name='episode', add_args=[]):
    """ Returns the link-target for an Episode, preferring slugs over Ids

    automatically distringuishes between relational Episode objects and
    CouchDB-based Episodes """

    from mygpo.core.models import Podcast

    # prefer slugs
    if episode.slug:
        args = [podcast.slug or podcast.get_id(), episode.slug]
        view_name = '%s-slug-id' % view_name

    # for short URLs, prefer oldids over CouchDB-IDs
    elif episode.oldid:
        args = [episode.oldid]

    # fallback: CouchDB-IDs
    else:
        if not podcast:
            if isinstance(episode.podcast, Podcast):
                podcast = episode.podcast
            elif isinstance(episode.podcast, basestring):
                podcast = Podcast.get(episode.podcast)

        args = [podcast.slug or podcast.get_id(), episode._id]
        view_name = '%s-slug-id' % view_name

    return strip_tags(reverse(view_name, args=args + add_args))

def podcast_slugs(base_slug):
    res = Podcast.view('podcasts/by_slug',
            startkey = [base_slug, None],
            endkey   = [base_slug + 'ZZZZZ', None],
            wrap_doc = False,
        )
    return [r['key'][0] for r in res]

    def handle(self, *args, **options):

        silent = options.get('silent')

        # couchdbkit doesn't preserve microseconds
        started = datetime.utcnow().replace(microsecond=0)

        podcasts = Podcast.all_podcasts()
        total = Podcast.view('podcasts/by_oldid', limit=0).total_rows

        for n, podcast in enumerate(podcasts):
            subscriber_count = self.get_subscriber_count(podcast)
            self.update(podcast=podcast, started=started, subscriber_count=subscriber_count)

            if not silent:
                progress(n, total)

def _wrap_podcast_group(res):
    if res['doc']['doc_type'] == 'Podcast':
        return Podcast.wrap(res['doc'])
    else:
        pg = PodcastGroup.wrap(res['doc'])
        id = res['key']
        return pg.get_podcast_by_id(id)