diff options
Diffstat (limited to 'web/controllers')
| -rw-r--r-- | web/controllers/__init__.py | 8 | ||||
| -rw-r--r-- | web/controllers/abstract.py | 116 | ||||
| -rw-r--r-- | web/controllers/article.py | 73 | ||||
| -rw-r--r-- | web/controllers/feed.py | 70 | ||||
| -rw-r--r-- | web/controllers/icon.py | 23 | ||||
| -rw-r--r-- | web/controllers/user.py | 7 |
6 files changed, 297 insertions, 0 deletions
diff --git a/web/controllers/__init__.py b/web/controllers/__init__.py new file mode 100644 index 00000000..ad77fa1d --- /dev/null +++ b/web/controllers/__init__.py @@ -0,0 +1,8 @@ +from .feed import FeedController +from .article import ArticleController +from .user import UserController +from .icon import IconController + + +__all__ = ['FeedController', 'ArticleController', 'UserController', + 'IconController'] diff --git a/web/controllers/abstract.py b/web/controllers/abstract.py new file mode 100644 index 00000000..f33d241e --- /dev/null +++ b/web/controllers/abstract.py @@ -0,0 +1,116 @@ +import logging +from flask import g +from bootstrap import db +from sqlalchemy import or_ +from werkzeug.exceptions import Forbidden, NotFound + +logger = logging.getLogger(__name__) + + +class AbstractController(object): + _db_cls = None # reference to the database class + _user_id_key = 'user_id' + + def __init__(self, user_id=None): + """User id is a right management mechanism that should be used to + filter objects in database on their denormalized "user_id" field + (or "id" field for users). + Should no user_id be provided, the Controller won't apply any filter + allowing for a kind of "super user" mode. + """ + self.user_id = user_id + try: + if self.user_id is not None \ + and self.user_id != g.user.id and not g.user.is_admin(): + self.user_id = g.user.id + except RuntimeError: # passing on out of context errors + pass + + def _to_filters(self, **filters): + """ + Will translate filters to sqlalchemy filter. + This method will also apply user_id restriction if available. + + each parameters of the function is treated as an equality unless the + name of the parameter ends with either "__gt", "__lt", "__ge", "__le", + "__ne", "__in" ir "__like". + """ + db_filters = set() + for key, value in filters.items(): + if key == '__or__': + db_filters.add(or_(*self._to_filters(**value))) + elif key.endswith('__gt'): + db_filters.add(getattr(self._db_cls, key[:-4]) > value) + elif key.endswith('__lt'): + db_filters.add(getattr(self._db_cls, key[:-4]) < value) + elif key.endswith('__ge'): + db_filters.add(getattr(self._db_cls, key[:-4]) >= value) + elif key.endswith('__le'): + db_filters.add(getattr(self._db_cls, key[:-4]) <= value) + elif key.endswith('__ne'): + db_filters.add(getattr(self._db_cls, key[:-4]) != value) + elif key.endswith('__in'): + db_filters.add(getattr(self._db_cls, key[:-4]).in_(value)) + elif key.endswith('__like'): + db_filters.add(getattr(self._db_cls, key[:-6]).like(value)) + elif key.endswith('__ilike'): + db_filters.add(getattr(self._db_cls, key[:-7]).ilike(value)) + else: + db_filters.add(getattr(self._db_cls, key) == value) + return db_filters + + def _get(self, **filters): + """ Will add the current user id if that one is not none (in which case + the decision has been made in the code that the query shouldn't be user + dependant) and the user is not an admin and the filters doesn't already + contains a filter for that user. + """ + if self._user_id_key is not None and self.user_id \ + and filters.get(self._user_id_key) != self.user_id: + filters[self._user_id_key] = self.user_id + return self._db_cls.query.filter(*self._to_filters(**filters)) + + def get(self, **filters): + """Will return one single objects corresponding to filters""" + obj = self._get(**filters).first() + + if obj and not self._has_right_on(obj): + raise Forbidden({'message': 'No authorized to access %r (%r)' + % (self._db_cls.__class__.__name__, filters)}) + if not obj: + raise NotFound({'message': 'No %r (%r)' + % (self._db_cls.__class__.__name__, filters)}) + return obj + + def create(self, **attrs): + assert self._user_id_key is None or self._user_id_key in attrs \ + or self.user_id is not None, \ + "You must provide user_id one way or another" + + if self._user_id_key is not None and self._user_id_key not in attrs: + attrs[self._user_id_key] = self.user_id + obj = self._db_cls(**attrs) + db.session.add(obj) + db.session.commit() + return obj + + def read(self, **filters): + return self._get(**filters) + + def update(self, filters, attrs): + result = self._get(**filters).update(attrs, synchronize_session=False) + db.session.commit() + return result + + def delete(self, obj_id): + obj = self.get(id=obj_id) + db.session.delete(obj) + db.session.commit() + return obj + + def _has_right_on(self, obj): + # user_id == None is like being admin + if self._user_id_key is None: + return True + return self.user_id is None \ + or getattr(obj, self._user_id_key, None) == self.user_id diff --git a/web/controllers/article.py b/web/controllers/article.py new file mode 100644 index 00000000..8b6926b7 --- /dev/null +++ b/web/controllers/article.py @@ -0,0 +1,73 @@ +import re +import logging +from sqlalchemy import func + +from bootstrap import db +from .abstract import AbstractController +from web.controllers import FeedController +from web.models import Article + +logger = logging.getLogger(__name__) + + +class ArticleController(AbstractController): + _db_cls = Article + + def get(self, **filters): + article = super(ArticleController, self).get(**filters) + if not article.readed: + self.update({'id': article.id}, {'readed': True}) + return article + + def challenge(self, ids): + """Will return each id that wasn't found in the database.""" + for id_ in ids: + if self.read(**id_).first(): + continue + yield id_ + + def count_by_feed(self, **filters): + if self.user_id: + filters['user_id'] = self.user_id + return dict(db.session.query(Article.feed_id, func.count(Article.id)) + .filter(*self._to_filters(**filters)) + .group_by(Article.feed_id).all()) + + def count_by_user_id(self, **filters): + return dict(db.session.query(Article.user_id, + func.count(Article.id)) + .filter(*self._to_filters(**filters)) + .group_by(Article.user_id).all()) + + def create(self, **attrs): + # handling special denorm for article rights + assert 'feed_id' in attrs + feed = FeedController( + attrs.get('user_id', self.user_id)).get(id=attrs['feed_id']) + if 'user_id' in attrs: + assert feed.user_id == attrs['user_id'] or self.user_id is None + attrs['user_id'] = feed.user_id + + # handling feed's filters + for filter_ in feed.filters or []: + match = False + if filter_.get('type') == 'regex': + match = re.match(filter_['pattern'], attrs.get('title', '')) + elif filter_.get('type') == 'simple match': + match = filter_['pattern'] in attrs.get('title', '') + take_action = match and filter_.get('action on') == 'match' \ + or not match and filter_.get('action on') == 'no match' + + if not take_action: + continue + + if filter_.get('action') == 'mark as read': + attrs['readed'] = True + logger.warn("article %s will be created as read", + attrs['link']) + elif filter_.get('action') == 'mark as favorite': + attrs['like'] = True + logger.warn("article %s will be created as liked", + attrs['link']) + + return super().create(**attrs) diff --git a/web/controllers/feed.py b/web/controllers/feed.py new file mode 100644 index 00000000..15be8663 --- /dev/null +++ b/web/controllers/feed.py @@ -0,0 +1,70 @@ +#! /usr/bin/env python +# -*- coding: utf-8 -*- + +# jarr - A Web based news aggregator. +# Copyright (C) 2010-2015 Cédric Bonhomme - https://www.JARR-aggregator.org +# +# For more information : https://github.com/JARR-aggregator/JARR/ +# +# This program is free software: you can redistribute it and/or modify +# it under the terms of the GNU Affero General Public License as +# published by the Free Software Foundation, either version 3 of the +# License, or (at your option) any later version. +# +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +# GNU Affero General Public License for more details. +# +# You should have received a copy of the GNU Affero General Public License +# along with this program. If not, see <http://www.gnu.org/licenses/>. + +import logging +from datetime import datetime, timedelta + +import conf +from .abstract import AbstractController +from .icon import IconController +from web.models import Feed + +logger = logging.getLogger(__name__) +DEFAULT_LIMIT = 5 +DEFAULT_REFRESH_RATE = 60 +DEFAULT_MAX_ERROR = conf.DEFAULT_MAX_ERROR + + +class FeedController(AbstractController): + _db_cls = Feed + + def list_late(self, max_last, max_error=DEFAULT_MAX_ERROR, + limit=DEFAULT_LIMIT): + return [feed for feed in self.read( + error_count__lt=max_error, enabled=True, + last_retrieved__lt=max_last) + .order_by('last_retrieved') + .limit(limit)] + + def list_fetchable(self, max_error=DEFAULT_MAX_ERROR, limit=DEFAULT_LIMIT, + refresh_rate=DEFAULT_REFRESH_RATE): + now = datetime.now() + max_last = now - timedelta(minutes=refresh_rate) + feeds = self.list_late(max_last, max_error, limit) + if feeds: + self.update({'id__in': [feed.id for feed in feeds]}, + {'last_retrieved': now}) + return feeds + + def _ensure_icon(self, attrs): + if not attrs.get('icon_url'): + return + icon_contr = IconController() + if not icon_contr.read(url=attrs['icon_url']).count(): + icon_contr.create(**{'url': attrs['icon_url']}) + + def create(self, **attrs): + self._ensure_icon(attrs) + return super().create(**attrs) + + def update(self, filters, attrs): + self._ensure_icon(attrs) + return super().update(filters, attrs) diff --git a/web/controllers/icon.py b/web/controllers/icon.py new file mode 100644 index 00000000..07c4a4ef --- /dev/null +++ b/web/controllers/icon.py @@ -0,0 +1,23 @@ +import base64 +import requests +from web.models import Icon +from .abstract import AbstractController + + +class IconController(AbstractController): + _db_cls = Icon + _user_id_key = None + + def _build_from_url(self, attrs): + if 'url' in attrs and 'content' not in attrs: + resp = requests.get(attrs['url'], verify=False) + attrs.update({'url': resp.url, + 'mimetype': resp.headers.get('content-type', None), + 'content': base64.b64encode(resp.content).decode('utf8')}) + return attrs + + def create(self, **attrs): + return super().create(**self._build_from_url(attrs)) + + def update(self, filters, attrs): + return super().update(filters, self._build_from_url(attrs)) diff --git a/web/controllers/user.py b/web/controllers/user.py new file mode 100644 index 00000000..3f96b185 --- /dev/null +++ b/web/controllers/user.py @@ -0,0 +1,7 @@ +from .abstract import AbstractController +from web.models import User + + +class UserController(AbstractController): + _db_cls = User + _user_id_key = 'id' |