def getsingle():
connect('c')
storedata = {}
name1 = request.args.get('name1')
type = request.args.get('type')
if " " in name1:
name1 = name1.replace(" ", "")
if (type == 'json'):
for t in Crime.objects:
if (t.id == name1):
storedata[t.id] = t.data
return jsonify({'alldata': storedata}), 200
if (type == 'xml'):
for t in Crime.objects:
if (t.id == name1):
nowtime = datetime.datetime.fromtimestamp(time.time())
xml = dicttoxml.dicttoxml(t.data[0], custom_root='content')
dom = parseString(xml).toprettyxml()
dom = re.sub('<\?xml version="[0-9]*\.[0-9]*" \?>\n', '', dom)
feed = AtomFeed(
id=
'https://mlab.com/databases/my-database/collections/crime/'
+ t.id,
title=t.id,
updated=nowtime,
author="z5129269")
storedata[t.id] = feed.to_string() + dom
return jsonify({'alldata': storedata}), 200
def feed():
latest_feed = AtomFeed("{0} - Posts".format(app.config['SETTINGS_TITLE']),
feed_url=request.url,
url=request.url_root)
roles = computed_user_roles()
latest_posts = Post.query \
.filter_by(status='published') \
.join(Category) \
.filter(Category.roles.any(Role.id.in_(roles))) \
.join(PostRating) \
.order_by(desc(Post.creation_date)) \
.limit(15) \
.all()
for post in latest_posts:
author = ''
if post.user:
author = post.user.username
updated = post.edit_date if post.edit_date else post.creation_date
latest_feed.add(post.title,
unicode(post.content),
content_type='html',
author=author,
url=url_for('posts.view',
category=post.category.url,
uuid=post.uuid,
slug=post.slug,
_external=True),
updated=updated,
published=post.creation_date)
return latest_feed.get_response()
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()
def feed_folder(folder):
if folder.split('/')[0] != 'admin':
folder = Folder.query.filter(guid=folder).one()
if folder:
posts = Post.query.filter(folder_id=folder.id,
status='published',
type='post').order_by('created').limit(
20, 0, array=True)
feed = AtomFeed(g.options['name'] + ' • ' + folder.name,
subtitle=folder.seo_content,
feed_url=request.url_root + 'feed/',
url=request.url_root,
generator=None)
for post in posts:
feed.add(post.title,
post.content,
content_type='html',
author=post.user.nicename,
url=request.url_root + post.guid,
updated=post.modified,
published=post.created)
response = feed.get_response()
response.headers["Content-Type"] = 'application/xml'
return response
else:
return is_404()
else:
return is_admin_404()
def recentAtom():
feed = AtomFeed(
title="Recent Items",
feed_url=request.url,
url=request.host_url,
subtitle="The most recently created catalog items.",
)
for item in db_session.query(Item) \
.order_by(Item.updated_on.desc()) \
.limit(10):
categories = [{
'term': tag.name.lower(),
'label': tag.name
} for tag in item.tags]
feed.add(title=item.name,
url=url_for('viewItem', item_name=item.name, item_id=item.id),
updated=item.updated_on,
published=item.created_on,
content_type='text',
content=unicode(item.description),
categories=categories,
author={
'name': "Random dude",
'email': '*****@*****.**'
})
# Replace with user once auth in place
return feed.get_response()
def feeds_public(sort=None):
page = int(request.args.get("page", 1))
t = request.args.get('t')
posts = frontlist(sort=sort,
page=page,
t=t,
v=None,
hide_offensive=False,
ids_only=False)
feed = AtomFeed(title=f'Top 5 {sort} Posts from ruqqus',
feed_url=request.url,
url=request.url_root)
for post in posts:
feed.add(post.title,
post.body_html,
content_type='html',
author=post.author.username,
url=full_link(post.permalink),
updated=datetime.fromtimestamp(post.created_utc),
published=datetime.fromtimestamp(post.created_utc),
links=[{
'href': post.url
}])
return feed.get_response()
def recent_feed():
feed = AtomFeed(_('Last reuses'),
feed_url=request.url,
url=request.url_root)
reuses = Reuse.objects.visible().order_by('-created_at').limit(15)
for reuse in reuses:
author = None
if reuse.organization:
author = {
'name':
reuse.organization.name,
'uri':
url_for('organizations.show',
org=reuse.organization.id,
_external=True),
}
elif reuse.owner:
author = {
'name': reuse.owner.fullname,
'uri': url_for('users.show',
user=reuse.owner.id,
_external=True),
}
feed.add(reuse.title,
render_template('reuse/feed_item.html', reuse=reuse),
content_type='html',
author=author,
url=url_for('reuses.show', reuse=reuse.id, _external=True),
updated=reuse.created_at,
published=reuse.created_at)
return feed.get_response()
def recent_episodes():
feed = AtomFeed(
title='Arrowverse.info - Recent Episodes',
feed_url=request.url,
url=request.url_root,
logo=url_for('static', filename='favicon.png', _external=True),
icon=url_for('static', filename='favicon.png', _external=True),
)
hide_shows_list = request.args.getlist('hide_show')
newest_first_episode_list = get_full_series_episode_list(
excluded_series=hide_shows_list)[::-1]
for episode in newest_first_episode_list[:15]:
title = '{series} - {episode_id} - {episode_name}'.format(**episode)
content = '{series} {episode_id} {episode_name} will air on {air_date}'.format(
**episode)
show_dict = app.config['SHOW_DICT_WITH_NAMES'][episode['series']]
data_source = f"{show_dict['root']}{show_dict['url']}"
feed.add(
title=title,
content=content,
content_type='text',
url=data_source,
author=show_dict['root'],
updated=datetime.now(),
)
return feed.get_response()
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()
def feed():
"""Returns 50 latest plays"""
feed = AtomFeed('Home Runs Only',
feed_url=request.url,
url=request.url_root)
plays = Play.query.order_by(Play.at.desc()).limit(50)
for play in plays:
feed.add(play.catchy_journalist_title(),
'Home run hit by {batter} off of {pitcher} on {date}'.format(
batter=play.batter.get_full_name(),
pitcher=play.pitcher.get_full_name(),
date=play.at.strftime('%B %d, %Y'),
),
content_type='html',
author=play.pitcher.get_full_name(),
url=urlparse.urljoin(
request.url_root,
url_for('view_play', content_id=play.content_id)),
updated=play.at,
published=play.at)
return feed.get_response()
def test_atom_add_one(self):
a = AtomFeed(title='test_title', id=1)
f = FeedEntry(
title='test_title', id=1, updated=datetime.datetime.now())
assert len(a.entries) == 0
a.add(f)
assert len(a.entries) == 1
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()
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()
def _topic_feed(request, title, query, order_by):
# non moderators cannot see deleted posts, so we filter them out first
# for moderators we mark the posts up as deleted so that
# they can be kept apart from non-deleted ones.
if not request.user or not request.user.is_moderator:
query = query.filter_by(is_deleted=False)
query = query.order_by(_topic_order[order_by])
query = query.options(eagerload('author'), eagerload('question'))
query = query.limit(max(0, min(50, request.args.get('num', 10, type=int))))
feed = AtomFeed(u'%s — %s' % (title, settings.WEBSITE_TITLE),
subtitle=settings.WEBSITE_TAGLINE,
feed_url=request.url,
url=request.url_root)
for topic in query.all():
title = topic.title
if topic.is_deleted:
title += u' ' + _(u'(deleted)')
feed.add(title,
topic.question.rendered_text,
content_type='html',
author=topic.author.display_name,
url=url_for(topic, _external=True),
id=topic.guid,
updated=topic.last_change,
published=topic.date)
return feed.get_response()
def feeds(sort=None):
cutoff = int(time.time()) - (60 * 60 * 24) # 1 day
posts = db.query(Submission).filter(Submission.created_utc>=cutoff,
Submission.is_banned == False,
Submission.is_deleted == False,
Submission.stickied == False)
if sort == "hot":
posts = posts.order_by(text("submissions.rank_hot desc"))
elif sort == "fiery":
posts = posts.order_by(text("submissions.rank_fiery desc"))
elif sort == "top":
posts = posts.order_by(text("submissions.score desc"))
feed = AtomFeed(title=f'Top 5 {sort} Posts from ruqqus',
feed_url=request.url, url=request.url_root)
posts = posts.limit(5).all()
for post in posts:
feed.add(post.title, post.body_html,
content_type='html',
author=post.author.username,
url=f"https://ruqqus.com{post.permalink}",
updated=datetime.fromtimestamp(post.created_utc),
published=datetime.fromtimestamp(post.created_utc))
return feed.get_response()
def build_feed():
feed = AtomFeed(current_app.config['SITE_NAME'],
feed_url=current_app.config['DOMAIN'] + 'rss.xml',
url=current_app.config['DOMAIN'],
subtitle=current_app.config['SUBTITLE'],
author=current_app.config['AUTHOR'],
updated=datetime.datetime.now())
entries = Entry.get_all_published()
for _entry in entries:
time = datetime.datetime.strptime(_entry['date'], '%Y-%m-%d %H:%M:%S')
feed.add(unicode(_entry['title']),
unicode(markdown(_entry['content'])),
content_type='html',
author=current_app.config['AUTHOR'],
published=time,
updated=time,
id=current_app.config['DOMAIN'] + _entry['slug'] + '/',
url=current_app.config['DOMAIN'] + 'posts/' + _entry['slug'] +
'/')
with codecs.open(BASE_DIR + '/rss.xml', 'w', 'utf-8-sig') as f:
f.write(feed.to_string())
def feed_view():
data = [
g.redis.hgetall("{}:{}".format(GLOBAL['ProcessName'], imgId))
for imgId in list(g.redis.smembers(picKey))
]
data = [
i
for i in sorted(data,
key=lambda k: (k.get('ctime', 0), k.get('imgUrl', 0)),
reverse=True)
][:15]
feed = AtomFeed(g.site["site_RssTitle"],
subtitle='Cherry Blossoms',
feed_url=request.url,
url=request.url_root,
icon=url_for('static',
filename='images/favicon.ico',
_external=True),
author=__author__)
for img in data:
title = timestamp_datetime(float(img['ctime']))
content = u'<img src="{}">'.format(img['imgUrl'])
feed.add(title,
content,
content_type='html',
id=img['imgId'],
url=img['imgUrl'],
author=__author__,
updated=datetime.datetime.fromtimestamp(float(img['ctime'])),
published=datetime.datetime.fromtimestamp(float(
img['ctime'])))
return feed.get_response()
def feed(name):
if current_app.config.get('PRIVATE_WIKI') and current_user.is_anonymous:
return current_app.login_manager.unauthorized()
cname = to_canonical(name)
wiki_name = current_app.config['SITE_TITLE']
start = 0
length = int(request.args.get('length', 20))
the_feed = AtomFeed(
title="{} - Recent changes for page '{}'".format(wiki_name, cname),
url=url_for('wiki.page', name=cname, _external=True),
id="{}_pagefeed_{}".format(to_canonical(wiki_name), cname),
feed_url=url_for('wiki.feed', name=cname, _external=True),
generator=("Realms wiki", 'https://github.com/scragg0x/realms-wiki', __version__)
)
page = g.current_wiki.get_page(cname)
items = list(itertools.islice(page.history, start, start + length)) # type: list[dict]
for item in items:
the_feed.add(
title="Commit '{}'".format(item['sha']),
content=item['message'],
url=url_for('wiki.commit', name=name, sha=item['sha'], _external=True),
id="{}/{}".format(item['sha'], cname),
author=item['author'],
updated=datetime.fromtimestamp(item['time'])
)
response = make_response((the_feed.to_string(), {'Content-type': 'application/atom+xml; charset=utf-8'}))
response.add_etag()
return response.make_conditional(request)
def feeds_guild(sort=None, guildname=None):
if not guildname:
abort(404)
guild = get_guild(guildname)
page = int(request.args.get("page", 1))
t = request.args.get('t')
ids = guild.idlist(sort=sort, page=page, t=t)
posts = get_posts(ids, sort=sort)
feed = AtomFeed(
title=f'{sort.capitalize()} posts from +{guild.name} on ruqqus',
feed_url=request.url,
url=request.url_root)
for post in posts:
feed.add(post.title,
post.body_html,
content_type='html',
author=post.author.username,
url=full_link(post.permalink),
updated=datetime.fromtimestamp(post.created_utc),
published=datetime.fromtimestamp(post.created_utc),
links=[{
'href': post.url
}])
return feed.get_response()
def get(self, name):
setting = current_app.config.get('SITE', {
'title': '',
'description': ''
})
title = setting['title']
description = setting['description']
feed = AtomFeed('%s·%s' % (name, title),
feed_url=request.url,
url=request.url_root,
subtitle=description)
topics = Topic.query.filter_by(tags__name=name).limit(10)
for topic in topics:
if topic.content_type == Topic.CONTENT_TYPE_MARKDOWN:
content = topic.content
else:
content = topic.content
feed.add(topic.title,
content,
content_type='html',
author=topic.author.username,
url=urljoin(request.url_root,
url_for('topic.topic', topicId=topic.id)),
updated=topic.updated_at,
published=topic.created_at)
return feed.get_response()
def feed_latest_posts():
feed_url = request.url
url_root = request.url_root.strip("/")
if "SITE_URL" in app.config:
url_root = app.config["SITE_URL"]
feed_url = "%s%s" % (url_root, request.path)
feed = AtomFeed("Recent posts", feed_url=feed_url, url=url_root)
posts = Post.query.order_by(desc(Post.date)).\
filter(Post.status == PostStatus.PUBLISH).\
filter(Post.type == PostType.POST)
for post in posts:
content = post.content
if post.markdown:
content = markdown.markdown(content)
if post.author:
author_name = post.author.nicename
else:
author_name = "Empty"
feed.add(post.title,
unicode(content),
content_type='html',
author=author_name,
url="%s/%s" % (url_root, post.name),
updated=post.date,
published=post.modified)
return feed.get_response()
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()
def feed():
feed = AtomFeed(g.options['name'],
subtitle=g.options['slogan'],
feed_url=request.url_root + 'feed/',
url=request.url_root,
generator=None)
posts = Post.query.filter(
status='published', type='post').order_by('created').limit(20,
0,
array=True)
for post in posts:
feed.add(post.title,
post.content,
content_type='html',
author=post.user.nicename,
url=request.url_root + post.guid,
updated=post.modified,
published=post.created)
response = feed.get_response()
response.headers["Content-Type"] = 'application/xml'
return response
def feed(uid):
blog = Blog.query.get_or_404(uid)
if not blog.is_approved and not blog.for_special_purpose:
abort(404)
if blog.feed:
abort(404)
feed = AtomFeed(blog.title,
feed_url=request.url,
url=blog.url,
id=blog.url)
if blog.subtitle:
feed.subtitle = blog.subtitle
for post in blog.posts.filter(~Post.hide). \
order_by(Post.published_at.desc(), Post.updated_at.desc()).limit(15):
updated = post.published_at if post.published_at else post.updated_at
feed.add(post.title,
post.content,
content_type='html',
author=blog.author,
url=post.url,
id=post.url,
updated=updated)
response = feed.get_response()
response.headers['Content-Type'] = 'application/xml'
return response
def activity_feed():
feed = AtomFeed('Site activity',
feed_url=request.url,
url=request.url_root)
activities = Activity.objects.order_by('-created_at').limit(
current_site.feed_size)
for activity in activities:
feed.add('Activity', 'Description')
# datasets = Dataset.objects.visible().order_by('-date').limit(15)
# for dataset in datasets:
# author = None
# if dataset.organization:
# author = {
# 'name': dataset.organization.name,
# 'uri': url_for('organizations.show', org=dataset.organization, _external=True),
# }
# elif dataset.owner:
# author = {
# 'name': dataset.owner.fullname,
# 'uri': url_for('users.show', user=dataset.owner, _external=True),
# }
# feed.add(dataset.title, dataset.description,
# content_type='html',
# author=author,
# url=url_for('datasets.show', dataset=dataset, _external=True),
# updated=dataset.last_modified,
# published=dataset.created_at)
return feed.get_response()
def recent_feed():
feed_title = OctBlogSettings['blog_meta']['name']
feed = AtomFeed(feed_title, feed_url=request.url, url=request.url_root)
# data = {}
# data['allow_donate'] = OctBlogSettings['donation']['allow_donate']
# data['donation_msg'] = OctBlogSettings['donation']['donation_msg']
# data['display_wechat'] = OctBlogSettings['wechat']['display_wechat']
# data['wechat_msg'] = OctBlogSettings['wechat']['wechat_msg']
# data['display_copyright'] = OctBlogSettings['copyright']['display_copyright']
# data['copyright_msg'] = OctBlogSettings['copyright']['copyright_msg']
# post_footer = get_post_footer(**data)
posts = models.Post.objects.filter(post_type='post', is_draft=False)[:15]
only_abstract_in_feed = OctBlogSettings['only_abstract_in_feed']
content = 'abstract' if only_abstract_in_feed else 'content_html'
for post in posts:
# return post.get_absolute_url()
feed.add(
post.title,
# unicode(post.content_html),
# post.abstract,
getattr(post, content),
content_type='html',
author=post.author.username,
url=post.get_absolute_url(),
updated=post.update_time,
published=post.pub_time)
return feed.get_response()
def atom_feed(subreddit_name=None, sort_type="hot"):
"""
"""
feed = AtomFeed(title=f"upvote.pub > {subreddit_name}",
feed_url=request.url, url=request.url_root)
# Pseudo frontpage subreddit --> None
if subreddit_name == 'frontpage':
subreddit_name = None
subreddit = Subreddit.query.filter_by(name=subreddit_name).first()
trending = True if request.args.get('trending') else False
thread_paginator = process_thread_paginator(trending=trending,
subreddit=subreddit,
sort_type=sort_type)
for thread in thread_paginator.items:
thread_url = url_for('threads.thread_permalink',
subreddit_name=thread.subreddit.name,
thread_id=thread.id,
title=slugify(thread.publication.pub_title),
_external=True)
feed.add(thread.publication.pub_title, thread.publication.pub_abstract,
content_type='html',
author=thread.publication.pub_authors,
url=thread_url,
updated=thread.created_on,
published=thread.updated_on)
return feed.get_response()
def create_atom_feed(name, data, query, size, start, url, to_atom):
if query == '*':
title_query = 'All'
else:
title_query = query
title = '{name}: Atom Feed for query: "{title_query}"'.format(
name=name, title_query=title_query)
author = 'COS'
links = [{
'href': '{url}?page=1'.format(url=url),
'rel': 'first'
}, {
'href':
'{url}?page={page}'.format(url=url, page=(start / size) + 2),
'rel':
'next'
}, {
'href': '{url}?page={page}'.format(url=url, page=(start / size)),
'rel': 'previous'
}]
links = links[1:-1] if (start / size) == 0 else links
feed = AtomFeed(title=title, feed_url=url, author=author, links=links)
for doc in data:
feed.add(**to_atom(doc))
return feed
def recent_feed():
feed_title = OctBlogSettings['blog_meta']['name']
feed = AtomFeed(feed_title, feed_url=request.url, url=request.url_root,
icon=url_for('static', filename='img/favicon-32x32.png', _external=True),
logo=url_for('static', filename='img/favicon-96x96.png', _external=True))
data = {}
data['allow_donate'] = OctBlogSettings['donation']['allow_donate']
data['donation_msg'] = OctBlogSettings['donation']['donation_msg']
data['display_wechat'] = OctBlogSettings['wechat']['display_wechat']
data['wechat_msg'] = OctBlogSettings['wechat']['wechat_msg']
data['display_copyright'] = OctBlogSettings['copyright']['display_copyright']
data['copyright_msg'] = OctBlogSettings['copyright']['copyright_msg']
post_footer = get_post_footer(**data)
posts = models.Post.objects.filter(post_type='post', is_draft=False)[:15]
for post in posts:
# return post.get_absolute_url()
feed.add(post.title, unicode(post.content_html+post_footer),
content_type='html',
author=post.author.username,
url=make_external(post.get_absolute_url()),
updated=post.update_time,
published=post.pub_time)
return feed.get_response()
def recent_feed():
feed = AtomFeed('Recent Items',
feed_url=request.url,
url=request.url_root,
subtitle="Most recent items.")
items = session.query(Item).order_by(asc(Item.dateAdded))
for item in items:
categories = []
cat = {'term': item.category.name, 'label': 'none'}
categories.append(cat)
author = {'name': item.user.name, 'email': item.user.email}
item_id = request.url_root + 'catalog/items/' + str(item.id)
entry = FeedEntry(item.name,
item.description,
content_type='html',
author=author,
categories=categories,
added=item.dateAdded,
id=item_id,
published=item.dateAdded,
updated=item.lastUpdated)
feed.add(entry)
return feed.get_response()
