Rfactorization. Just a start...

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'