Python AtomFeed.get_response方法代码示例

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def feed_story(story_id):
    story = Story.select_published().filter(lambda x: x.id == story_id).prefetch(Story.chapters).first()
    if not story:
        abort(404)

    feed = AtomFeed(
        title=story.title,
        feed_url=request.url,
        url=request.url_root
    )

    chapters = [c for c in story.chapters if not c.draft]
    for c in chapters:
        assert c.first_published_at is not None, 'database is inconsistent: story {} has non-draft and non-published chapter {}'.format(story.id, c.order)
    chapters.sort(key=lambda x: (x.first_published_at, x.order), reverse=True)

    for chapter in chapters:
        data = chapter.text_preview
        feed.add(
            chapter.autotitle,
            data,
            content_type='text',
            url=url_for('chapter.view', story_id=story.id, chapter_order=chapter.order, _external=True),
            updated=chapter.updated,
            published=chapter.date,
        )
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def feed():
    blogging_engine = _get_blogging_engine(current_app)
    storage = blogging_engine.storage
    config = blogging_engine.config
    count = config.get("BLOGGING_FEED_LIMIT")
    posts = storage.get_posts(count=count, offset=None, recent=True,
                              user_id=None, tag=None, include_draft=False)

    feed = AtomFeed(
        '%s - All Articles' % config.get("BLOGGING_SITENAME",
                                         "Flask-Blogging"),
        feed_url=request.url, url=request.url_root, generator=None)

    if len(posts):
        feed_posts_fetched.send(blogging_engine.app, engine=blogging_engine,
                                posts=posts)
        for post in posts:
            blogging_engine.process_post(post, render=True)
            feed.add(post["title"], str(post["rendered_text"]),
                     content_type='html',
                     author=post["user_name"],
                     url=config.get("BLOGGING_SITEURL", "")+post["url"],
                     updated=post["last_modified_date"],
                     published=post["post_date"])
        feed_posts_processed.send(blogging_engine.app, engine=blogging_engine,
                                  feed=feed)
    response = feed.get_response()
    response.headers["Content-Type"] = "application/xml"
    return response

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def feed(site):
    if site == 'hackernews':
        title = 'Hacker News Digest'
        news_list = models.HackerNews.query.order_by('submit_time desc').all()
    else:
        title = 'Startup News Digest'
        news_list = models.StartupNews.query.order_by('submit_time desc').all()

    feed = AtomFeed(title,
                    updated=models.LastUpdated.get(site),
                    feed_url=request.url,
                    url=urljoin(request.url_root, url_for(site)),
                    author={
                        'name': 'polyrabbit',
                        'uri': 'https://github.com/polyrabbit/'}
                    )
    for news in news_list:
        feed.add(news.title,
                 content=news.summary and 
                 ('<img src="%s" style="width: 220px; float: left" />' % news.image.url if news.img_id else '') 
                     + news.summary,
                 author={
                     'name': news.author,
                     'uri': news.author_link
                 } if news.author_link else (),
                 url=news.url,
                 updated=news.submit_time,)
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def last_24_hr():
  posts = get_recent_posts(filter_recent=True)
  feed = AtomFeed('Recent Articles',
                  feed_url=request.url, url=request.url_root)
  for post in posts:
    add_post_to_feed(feed, post)
  return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def atomfeed():
    t = request.args.get('t')
    if not t:
        t = 'url'

    r = get_last(t)
    if not (r.status_code == 200 and len(r.response) > 0):
        return {}

    j = json.loads(r.response[0])

    if len(j) < 1:
        return {}

    feed = AtomFeed('Les liens (pas forcement) SFW de GCU-Squad!',
                    feed_url=request.url, url=request.url_root,
                    subtitle='Adresses vues sur le canal #[email protected]')
    for item in j:
        post = item['_source']
        for url in post['urls']:
            datefmt = '%Y-%m-%dT%H:%M:%S.%f'
            pubdate = datetime.datetime.strptime(post['fulldate'], datefmt)
            update = pubdate
            if post['tags']:
                line = '{0} #{1}#'.format(post['line'], ','.join(post['tags']))
            else:
                line = post['line']
            feed.add(title=line, title_type='text', url=url,
                     author=post['nick'], published=pubdate, updated=update)
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def recent_feed():
    feed = AtomFeed(_('Last datasets'),
                    feed_url=request.url, url=request.url_root)
    datasets = (Dataset.objects.visible().order_by('-created_at')
                .limit(current_site.feed_size))
    for dataset in datasets:
        author = None
        if dataset.organization:
            author = {
                'name': dataset.organization.name,
                'uri': url_for('organizations.show',
                               org=dataset.organization.id, _external=True),
            }
        elif dataset.owner:
            author = {
                'name': dataset.owner.fullname,
                'uri': url_for('users.show',
                               user=dataset.owner.id, _external=True),
            }
        feed.add(dataset.title,
                 render_template('dataset/feed_item.html', dataset=dataset),
                 content_type='html',
                 author=author,
                 url=url_for('datasets.show',
                             dataset=dataset.id, _external=True),
                 updated=dataset.last_modified,
                 published=dataset.created_at)
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def rss():
    feed = AtomFeed('Hacker News TLDR',
                    feed_url=request.url, url=request.url_root)
    stories = _get_stories()
    for story in stories:
        if not story.get(BODY, {}).get(SENTENCES):
            body = 'Unable to generate summary'
        else:
            body = '<ul>{}</ul>'.format(
                '\n'.join(
                    "<li>{}</li>".format(
                        sentence
                    ) for sentence in story[BODY][SENTENCES]
                )
            )
            body += "<br/><a href={}>HN Comments</a>".format(
                'https://news.ycombinator.com/item?id={}'.format(
                    story[HACKER_NEWS_ID]
                )
            )
        feed.add(story[TITLE], body,
                 content_type='html',
                 updated=datetime.strptime(
                     story[DATE_FOUND],
                     '%Y-%m-%d %H:%M:%S.%f'),
                 url=urljoin(request.url_root, story[URL]),
                 )
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def recent_atom():
    app.logger.debug(request.url_root)
    feed = AtomFeed('Recent Events', feed_url=request.url, url=request.url_root)
    events = session.query(Event).all()
    for e in events:
        feed.add(id=e.id, title=e.title, content_type='html', updated=e.created)
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def recent_feed():
    feed = AtomFeed('Recent Articles', feed_url=request.url, url=request.url_root)
    threads = Thread.query.order_by(Thread.last_updated.desc()).filter(Thread.user==None).all()
    for thread in threads:
        url = url_for('thread', display_hash=thread.display_hash, title=thread.slug())
        feed.add(thread.title, '', content_type='html', author=thread.display_name, url=url, updated=thread.last_updated, published=thread.date_created)
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def publictag_feed(tagkey):
    """ rss/atom representation of the Read-only overview of the bookmarks in the userkey/tag of this PublicTag """
    try:
        this_tag = PublicTag.get(PublicTag.tagkey == tagkey)
        bookmarks = Bookmark.select().where(
            Bookmark.userkey == this_tag.userkey,
            Bookmark.tags.contains(this_tag.tag),
            Bookmark.status == Bookmark.VISIBLE
        )
        feed = AtomFeed(this_tag.tag, feed_url=request.url, url=make_external(url_for('publictag_page', tagkey=tagkey)))
        for bookmark in bookmarks:
            updated_date = bookmark.modified_date
            if not bookmark.modified_date:
                updated_date = bookmark.created_date
            bookmarktitle = '{} (no title)'.format(bookmark.url)
            if bookmark.title:
                bookmarktitle = bookmark.title
            feed.add(
                bookmarktitle,
                content_type='html',
                author='digimarks',
                url=bookmark.url,
                updated=updated_date,
                published=bookmark.created_date
            )
        return feed.get_response()
    except PublicTag.DoesNotExist:
        abort(404)

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def blog_feed():
    posts = Gallery.get_list(published=True, to_json=True)

    feed_url = "{}/blog/feed.atom".format(g.app_base_link)
    feed = AtomFeed('KateHeddleston.com Blog Posts',
                    feed_url=feed_url,
                    url='{}/blog'.format(g.app_base_link))

    for post in posts:
        post_html = []
        for item in post.get('items'):
            item_text = ""
            if item.get('title'):
                item_text += u'<h2>{}</h2><br>'.format(item.get('title'))
            if item.get('image_name'):
                img_src = u'{}/{}'.format(post.get('base_url'), item.get('image_name'))
                item_text += u"<img src='{}' />".format(img_src)
            if item.get('image_caption'):
                item_text += u"<div>{}</div>".format(item.get('image_caption'))
            item_text += '<br>'
            item_text += item.get('body')
            post_html.append(item_text)
        text = '</p><p>'.join(post_html)
        text = '<p>' + text + '</p>'

        post_url = "{}/blog/{}".format(g.app_base_link, post.get('uuid'))
        published_at = datetime.datetime.strptime(post['published_at_raw'], '%Y-%m-%dT%H:%M:%S')
        feed.add(post.get('name'),
                 unicode(text),
                 content_type='html',
                 author=post.get('author'),
                 url=post_url,
                 updated=published_at,
                 published=published_at)
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def get_feed(feed_id):
    feed_id = secure_filename(feed_id)
    feed_config_filepath = os.path.join(APP_CONFIG_FEEDS, feed_id+".json")
    if not os.path.isfile(feed_config_filepath):
        print feed_config_filepath
        abort(404)
    feed = feedops.FusedFeed.load_from_spec_file(feed_config_filepath)
    feed.fetch()
    feed_uri = request.url_root
    if len(feed.sources) == 1:
        # if there is only 1 source in a fusedfeed
        # just give the feed's html alternate
        # TODO: instead, we should generate our own HTML representation
        feed_uri = feed.sources[0].html_uri
    output = AtomFeed(feed.name, feed_url=request.url, author="FeedFuser", links=[{"href":feed_uri,
                                                                                  "rel":"alternate",
                                                                                  "type":"text/html"}])
    for entry in feed.entries:
        title = entry.title
        if not entry.title:
            title = entry.link
        feed_item = FeedEntry(id=entry.guid, title=title, updated=entry.update_date,
                              author=entry.author, published=entry.pub_date, links=[{"href":entry.link, "rel":"alternate", "type":"text/html"}])

        if entry.summary:
            feed_item.summary = unicode(entry.summary)
            feed_item.summary_type = "text" if entry.summary_type == "text/plain" else "html"
        if entry.content:
            feed_item.content = unicode(entry.content)
            feed_item.content_type = "text" if entry.content_type == "text/plain" else "html"
        output.add(feed_item)
    return output.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def rss(channel):
    urls = list(url_db.filter({'channel': channel}).run(g.rdb_conn))[:50]
    feed = AtomFeed('Recent URLs', feed_url=request.url, url=request.url_root)
    for url in urls:
        if url['type'].lower() == 'image':
            c = "<img src='" + url['url'] + "'></img>"
        else:
            c = "This URL is a {0}".format(url['type'])

        title = url.get('title', 'Missing Title')
        if title:
            if title == '':
                title = 'Missing Title'

        feed.add(title=title,
                 content=c,
                 content_type="xhtml",
                 author=url['user'],
                 url=url['url'],
                 updated=url['timestamp'],
                 published=url['timestamp'])

    data = feed.get_response()
    response = make_response(data)
    response.headers['Content-Type'] = 'application/atom+xml'
    return response

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def recent_items_feed():
    feed = AtomFeed('New Items',
                    feed_url=request.url, url=request.url_root)
    items = catalogDb.get_latest_items(CUT_OFF_DATE,
                                       NO_LATEST_ITEMS)
    for item in items:
        text = " New item in category " + get_category_name(item.category_id)
        text += " Price Range" + str(item.pricerange)
        text += " Item Description " + item.description[100:]
        text += "... Read more here "
        text += create_external_url(
            url_for('category_item',
                    category_name=format_name_for_url(
                        get_category_name(item.category_id)),
                    item_name=format_name_for_url(item.name),
                    item_id=item.id))

        feed.add(item.name, unicode(text),
                 content_type='html',
                 author="Sams Catalog App",
                 url=create_external_url(
            url_for('category_item',
                    category_name=format_name_for_url(
                        get_category_name(item.category_id)),
                    item_name=format_name_for_url(item.name),
                    item_id=item.id)),
                 updated=item.lastupdated or item.created,
                 published=item.created)
    return feed.get_response()

# 需要导入模块: from werkzeug.contrib.atom import AtomFeed [as 别名]
# 或者: from werkzeug.contrib.atom.AtomFeed import get_response [as 别名]
def announcement_feed():
    def bjdate(d):
        from datetime import timedelta
        return (d + timedelta(hours=8)).strftime('%Y年%m月%d日')

    type_ = request.args.get('type', '')
    typecn = type_to_cn(type_)
    exchange = request.args.get('exchange', '')
    cond = {}
    feedtitle = '邮币卡公告聚合'
    if type_:
        cond['type_'] = type_
        feedtitle += ' - {}'.format(typecn)
    if exchange:
        cond['exchange'] = exchange
        feedtitle += ' - {}'.format(exchange)

    feed = AtomFeed(feedtitle,
                    feed_url=request.url,
                    url=request.url_root)

    announcements = list(
        Announcement.query(cond,
            sort=[('updated_at', -1)], limit=20))

    for a in announcements:
        feed.add('{} {}'.format(bjdate(a.published_at), a.title.strip()),
                 '更多内容请点击标题连接',
                 content_type='text',
                 author=a.exchange,
                 url=a.url,
                 updated=a.updated_at,
                 published=a.published_at)
    return feed.get_response()