def search():
page = 1
body = json.get_request_body()
if 'page' in body:
page = int(body['page'])
params = {}
if 'type' in body:
params['filter_criteria'] = body['type']
if 'where' in body:
params['where'] = body['where']
from rdr.modules.feeds.search import ArticleSearchProvider
if 'feed' in body:
provider = ArticleSearchProvider(feeds=[int(body['feed'])], user=session_user.identity)
else:
provider = ArticleSearchProvider(user=session_user.identity)
ids = provider.search(body['query'], **params)
if ids:
articles_pagination = Article.query \
.options(db.joinedload(Article.statuses),
db.joinedload(Article.feed)) \
.filter((Article.active == True) & (Article.id.in_(ids))).order_by(Article.published.desc()) \
.paginate(page, per_page=60, error_out=False)
records = UserArticleRecord.wrap_articles_list(articles_pagination.items)
records = [x.to_dict() for x in records]
else:
records = []
return {
'success': True,
'articles': records
}
def get_article_info(article_id):
full_text = request.args.get('full-text')
article = Article.query.filter(Article.id == article_id).first()
if not article:
raise json.NotFound()
rec = UserArticleRecord.wrap_article(article)
res = {'success': True, 'article': rec.to_dict()}
if full_text:
model = fetch_full_text(article)
if model:
res['fullText'] = model.to_dict()
return res
def articles_unread_list():
page = 1
if 'page' in request.args:
page = int(request.args['page'])
from rdr.modules.feeds.articles.unread import TotalUnreadArticlesSet
unread_set = TotalUnreadArticlesSet(session_user.user)
articles_pagination = unread_set.query.options(db.joinedload(Article.feed)) \
.paginate(page, per_page=60, error_out=False)
records = UserArticleRecord.wrap_articles_list(articles_pagination.items)
return {
'success': True,
'articles': [x.to_dict() for x in records]
}
def home_dashboard():
from rdr.modules.home.dashboard.last_visit_news import LastVisitNewsGenerator, PopularNewsGenerator
from rdr.modules.feeds.articles.status import UserArticleRecord
articles = []
news_type = 'lastvisit'
identity = User.query.filter(User.id == user_session.identity.id).one()
if not identity.last_visit or (datetime.now() - identity.last_visit) >= timedelta(minutes=20):
gen = LastVisitNewsGenerator(user_session.identity)
articles = gen.fetch_articles()
if not articles:
news_type = 'popular'
gen = PopularNewsGenerator(user_session.identity, use_cache=False)
articles = gen.fetch_articles()
articles = UserArticleRecord.wrap_articles_list(articles)
return {
'success': True,
'news': [x.to_dict() for x in articles],
'type': news_type
}
def article_favorites_list():
page = 1
if 'page' in request.args:
page = int(request.args['page'])
user = session_user.user
from rdr.modules.feeds.models import ArticleFavorite
articles_pagination = Article.query \
.join(ArticleFavorite, (ArticleFavorite.user_id == user.id) & (ArticleFavorite.article_id == Article.id)) \
.options(db.joinedload(Article.statuses),
db.joinedload(Article.feed)) \
.filter((Article.active == True)).order_by(ArticleFavorite.fav_date.desc()) \
.paginate(page, per_page=60, error_out=False)
records = UserArticleRecord.wrap_articles_list(articles_pagination.items)
return {
'success': True,
'articles': [x.to_dict() for x in records]
}
def queue_list():
page = 1
if "page" in request.args:
page = int(request.args["page"])
user = session_user.user
from rdr.modules.feeds.models import Article
from rdr.modules.feeds.articles.status import UserArticleRecord
articles_pagination = (
Article.query.join(
OfflineReadQueue, (OfflineReadQueue.user_id == user.id) & (OfflineReadQueue.article_id == Article.id)
)
.options(db.joinedload(Article.statuses), db.joinedload(Article.feed))
.filter((Article.active == True))
.order_by(OfflineReadQueue.add_date.asc())
.paginate(page, per_page=60, error_out=False)
)
records = UserArticleRecord.wrap_articles_list(articles_pagination.items)
return {"success": True, "articles": [x.to_dict(full_text=True) for x in records]}
def articles_sync(feed_id):
page = 1
feed = Feed.query.filter(Feed.id == feed_id).first()
if not feed:
raise json.InvalidRequest("Unknown feed id")
default_update_pause_seconds = 300
if not feed.last_update or (datetime.now() - feed.last_update) > timedelta(seconds=default_update_pause_seconds):
synchronizer = ArticlesSynchronizer(feed)
synchronizer.sync()
articles_pagination = Article.query \
.filter((Article.feed_id == feed_id) & (Article.active == True)) \
.order_by(Article.published.desc()) \
.options(db.joinedload(Article.feed)) \
.paginate(page, per_page=40, error_out=False)
records = UserArticleRecord.wrap_articles_list(articles_pagination.items)
feed_record = UserPackageRecord.wrap_package(feed)
return {
'success': True,
'articles': [x.to_dict() for x in records],
'feed': feed_record.to_dict()
}
def articles_list(feed_id):
page = 1
if 'page' in request.args:
page = int(request.args['page'])
feed = Feed.query.filter(Feed.id == feed_id).first()
if not feed:
raise json.InvalidRequest("Unknown feed id")
if not feed.active:
activate_feed(feed)
articles_pagination = Article.query \
.filter((Article.feed_id == feed_id) & (Article.active == True)) \
.order_by(Article.published.desc()) \
.options(db.joinedload(Article.feed)) \
.paginate(page, per_page=40, error_out=False)
records = UserArticleRecord.wrap_articles_list(articles_pagination.items)
feed_record = UserPackageRecord.wrap_package(feed)
return {
'success': True,
'articles': [x.to_dict() for x in records],
'feed': feed_record.to_dict()
}
def generate_file(task_id, app_url='http://localhost:9000', file_format='PDF', lang='en'):
from rdr.modules.users.session import session_user
from rdr.modules.feeds.models import OfflineReadQueueTask
task = OfflineReadQueueTask.query.filter(OfflineReadQueueTask.id == task_id).one()
user = task.user
session_user.auth(user)
from rdr.application.i18n import format_datetime, gettext, ngettext, set_global_lang
set_global_lang(lang)
from rdr.application.database import db
from rdr.modules.feeds.models import Article, OfflineReadQueue
from rdr.modules.feeds.articles.status import UserArticleRecord
articles = Article.query \
.join(OfflineReadQueue, (OfflineReadQueue.user_id == user.id) & (OfflineReadQueue.article_id == Article.id)) \
.options(db.joinedload(Article.statuses),
db.joinedload(Article.feed)) \
.filter((Article.active == True)).order_by(OfflineReadQueue.add_date.asc())
records = UserArticleRecord.wrap_articles_list(articles)
dicts = [x.to_dict(full_text=True) for x in records]
if not dicts:
task.status = OfflineReadQueueTask.STATUS_REJECTED
db.session.commit()
return False
from jinja2 import Environment, FileSystemLoader
import os
from datetime import datetime
env = Environment(extensions=['jinja2.ext.i18n', 'jinja2.ext.autoescape', 'jinja2.ext.with_'], autoescape=True, loader=FileSystemLoader(
os.path.join(os.path.dirname(os.path.realpath(__file__)),
'..',
'..',
'modules',
'feeds',
'templates',
'offline-reading')
)
)
env.install_gettext_callables(gettext, ngettext, True)
template = env.get_template('pdf-std.jhtml')
content = template.render(articles=dicts,
url=app_url,
username=user.username,
gen_date=format_datetime(datetime.now(), 'dd MMM yyyy HH:mm'))
import pdfkit
from tempfile import NamedTemporaryFile
pdf_opts = {
'page-size': 'Letter'
}
f = NamedTemporaryFile(delete=False)
pdfkit.from_string(content, f.name, options=pdf_opts)
task.status = OfflineReadQueueTask.STATUS_FILE_GENERATED
task.out_file = f.name
db.session.commit()
return True
