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 _fetch_feeds_common(self): query = self.query if query and len(query) > 2: if self.is_url(query): match_feed = Feed.query.filter((Feed.url == query) | (Feed.channel_url == query)).first() if match_feed: return [match_feed] match_alias = FeedAliasUrl.query.filter(FeedAliasUrl.url == query).options( db.joinedload(FeedAliasUrl.feed) ).all() if match_alias: return lists.unique([m.feed for m in match_alias]) try: return self._resolve(query) except Exception as e: app.logger.exception(e) return [] #todo: add active matches = [] match_alias = FeedAliasKeyword.query.filter(FeedAliasKeyword.keyword.ilike('%' + query + '%')).options( db.joinedload(FeedAliasKeyword.feed) ).all() if match_alias: for alias in match_alias: matches.append(alias.feed) feeds = Feed.query.filter(Feed.title.ilike('%' + query + '%')).all() if feeds: for feed in feeds: matches.append(feed) return lists.unique(matches) return []
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 _fetch_feeds_channel(self): query = self.query if self.is_url(query): match_feed = Feed.query.filter(Feed.channel_url == query).first() if match_feed: return [match_feed] match_alias = FeedAliasUrl.query.filter(FeedAliasUrl.url == query).options( db.joinedload(FeedAliasUrl.feed) ).all() if match_alias: return lists.unique([m.feed for m in match_alias]) try: return self._resolve(query) except Exception as e: app.logger.exception(e) return []
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 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