Drop event listener and unused code

geokrety_api_models/geokret.py

@@ -4,7 +4,7 @@
 from datetime import datetime
 
 from sqlalchemy import (TIMESTAMP, Boolean, Column, DateTime, Enum, ForeignKey,
-                        Integer, String, Text, event, inspect)
+                        Integer, String, Text, event)
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import relationship
 from sqlalchemy.orm.exc import NoResultFound
@@ -81,7 +81,7 @@ class Geokret(Base):
         nullable=False,
         default=0,
     )
-    _created_on_datetime = Column(
+    created_on_datetime = Column(
         'data',
         DateTime,
         nullable=False,
@@ -211,22 +211,6 @@ def description(self, description):
     def description(cls):
         return cls._description
 
-    @hybrid_property
-    def created_on_datetime(self):
-        if self._created_on_datetime is None:
-            raise AssertionError("created_on_datetime is missing")
-        if isinstance(self._created_on_datetime, str):
-            self._created_on_datetime = datetime.strptime(self._created_on_datetime, "%Y-%m-%dT%H:%M:%S")
-        return round_microseconds(self._created_on_datetime)
-
-    @created_on_datetime.setter
-    def created_on_datetime(self, created_on_datetime):
-        self._created_on_datetime = created_on_datetime
-
-    @created_on_datetime.expression
-    def created_on_datetime(cls):
-        return cls._created_on_datetime
-
 
 @event.listens_for(Geokret, 'init')
 def receive_init(target, args, kwargs):
@@ -235,36 +219,11 @@ def receive_init(target, args, kwargs):
 
 @event.listens_for(Geokret, 'before_insert')
 def before_insert_listener(mapper, connection, target):
-    if not target._created_on_datetime:
-        target._created_on_datetime = round_microseconds(datetime.utcnow())
-    target.updated_on_datetime = target._created_on_datetime
+    if not target.created_on_datetime:
+        target.created_on_datetime = round_microseconds(datetime.utcnow())
+    target.updated_on_datetime = target.created_on_datetime
 
 
 @event.listens_for(Geokret, 'before_update')
 def before_update_listener(mapper, connection, target):
     target.updated_on_datetime = round_microseconds(datetime.utcnow())
-
-
-MONITORED_ATTRIBUTES = [
-    'tracking_code',
-    '_name',
-    '_description',
-    'type',
-    'missing',
-    'distance',
-    'caches_count',
-    'pictures_count',
-    'updated_on_datetime',
-    'owner_id',
-    'holder_id',
-    'last_position_id',
-    'last_move_id',
-]
-
-
-def _has_changes_that_need_event(instance):
-    instance_attrs = inspect(instance).attrs
-    for attribute in MONITORED_ATTRIBUTES:
-        if hasattr(instance_attrs, attribute) and \
-                getattr(instance_attrs, attribute).history.has_changes():
-            return True

geokrety_api_models/move.py

@@ -1,16 +1,14 @@
 # -*- coding: utf-8 -*-
 
-from datetime import datetime, timedelta
+from datetime import datetime
 
-from sqlalchemy import (Column, DateTime, Enum, ForeignKey, Integer, String,
-                        event, func, inspect, select)
+from sqlalchemy import Column, DateTime, Enum, ForeignKey, Integer, String
 from sqlalchemy.dialects.mysql import DOUBLE
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import backref, relationship
 
 import bleach
 import characterentities
-from geokrety_api_exceptions.json_api import GKUnprocessableEntity
 
 from .base import Base
 from .utilities.date import round_microseconds
@@ -233,46 +231,6 @@ def application_name(cls):
 
     @hybrid_property
     def _moved_on_datetime(self):
-        if self.moved_on_datetime is None:
-            raise AssertionError("moved_on_datetime is missing")
         if isinstance(self.moved_on_datetime, str):
             self.moved_on_datetime = datetime.strptime(self.moved_on_datetime, "%Y-%m-%dT%H:%M:%S")
         return round_microseconds(self.moved_on_datetime)
-
-
-@event.listens_for(Move, 'before_update')
-@event.listens_for(Move, 'before_insert')
-def my_before_insert_listener(mapper, connection, target):
-    if target.geokret is None:
-        raise GKUnprocessableEntity("Move must concern a GeoKret",
-                                    {'pointer': '/data/relationships/geokret'})
-
-    # Move cannot be done before GeoKret birth
-    if target._moved_on_datetime < target.geokret.created_on_datetime:
-        raise GKUnprocessableEntity("Move date cannot be prior GeoKret birth date",
-                                    {'pointer': '/data/attributes/moved-on-datetime'})
-
-    # Move cannot be done in the future
-    if target._moved_on_datetime > datetime.utcnow().replace(microsecond=0) + timedelta(seconds=1):
-        raise GKUnprocessableEntity("Move date cannot be in the future",
-                                    {'pointer': '/data/attributes/moved-on-datetime'})
-
-    # Identical move date is forbidden
-    if _has_changes_that_need_recompute(target):
-        move_table = Move.__table__
-        res = connection.execute(
-            select([func.count()]).select_from(move_table).
-            where(Move.moved_on_datetime == target.moved_on_datetime).
-            where(Move.geokret_id == target.geokret.id).
-            where(Move.id != target.id)
-        ).scalar()
-        if res > 0:
-            raise GKUnprocessableEntity("There is already a move at that time",
-                                        {'pointer': '/data/attributes/moved-on-datetime'})
-
-
-def _has_changes_that_need_recompute(instance):
-    if inspect(instance).attrs.type.history.has_changes() or \
-            inspect(instance).attrs.moved_on_datetime.history.has_changes() or \
-            inspect(instance).attrs.geokret.history.has_changes():
-        return True

geokrety_api_models/move_comment.py

@@ -2,8 +2,7 @@
 
 import datetime
 
-from sqlalchemy import (Column, DateTime, ForeignKey, Integer, String, event,
-                        inspect)
+from sqlalchemy import Column, DateTime, ForeignKey, Integer, String, event
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import relationship
 
@@ -131,9 +130,3 @@ def before_insert_listener(mapper, connection, target):
 @event.listens_for(MoveComment, "before_update")
 def before_update(mapper, connection, target):
     target.is_missing_authorized()
-
-
-def _has_changes_that_need_recompute(instance):
-    if inspect(instance).attrs.type.history.has_changes() or \
-            inspect(instance).attrs.move.history.has_changes():
-        return True

geokrety_api_models/user.py

@@ -4,8 +4,7 @@
 import random
 
 import phpass
-from sqlalchemy import (Boolean, Column, DateTime, Integer, String, event,
-                        inspect)
+from sqlalchemy import Boolean, Column, DateTime, Integer, String, event
 from sqlalchemy.dialects.mysql import DOUBLE, INTEGER
 from sqlalchemy.ext.hybrid import hybrid_property
 from sqlalchemy.orm import relationship
@@ -198,37 +197,3 @@ def name(cls):
 def receive_init(target, args, kwargs):
     target.secid = ''.join(random.choice('0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ') for i in range(84))  # TODO
     # target.ip = request.remote_addr
-
-
-MONITORED_ATTRIBUTES = [
-    '_name',
-    'is_admin',
-    '_password',
-    'email',
-    'daily_mails',
-    'ip',
-    'language',
-    'latitude',
-    'longitude',
-    'observation_radius',
-    'country',
-    'hour',
-    'statpic_id',
-    'last_mail_datetime',
-    'last_login_datetime',
-    'last_update_datetime',
-    'secid',
-]
-
-
-def _has_changes_that_need_event(instance):
-    instance_attrs = inspect(instance).attrs
-    for attribute in MONITORED_ATTRIBUTES:
-        if hasattr(instance_attrs, attribute) and \
-                getattr(instance_attrs, attribute).history.has_changes():
-            return True
-
-
-if __name__ == '__main__':
-    # Check
-    user = User()

geokrety_api_models/utilities/move_tasks.py

@@ -20,16 +20,16 @@ def update_geokret_and_moves(session, geokrety, moves=None):
         moves = [moves]
 
     for move_id in moves:
-        update_move_comments_type(move_id)
-        update_move_country_and_altitude(move_id)
+        update_move_comments_type(session, move_id)
+        update_move_country_and_altitude(session, move_id)
 
     for geokret_id in geokrety:
         # Enhance Move content
-        update_move_distances(geokret_id)
+        update_move_distances(session, geokret_id)
         # Enhance GeoKret content
-        update_geokret_total_moves_count(geokret_id)
-        update_geokret_holder(geokret_id)
-        update_geokret_missing(geokret_id)
+        update_geokret_total_moves_count(session, geokret_id)
+        update_geokret_holder(session, geokret_id)
+        update_geokret_missing(session, geokret_id)
 
     try:
         session.commit()
@@ -46,11 +46,16 @@ def update_geokret_and_moves(session, geokrety, moves=None):
     # *
 
 
-def update_move_distances(geokret_id):
+def update_move_distances(session, geokret_id):
     """ Recompute and update all moves distances for a GeoKret
     """
-    moves = Move.query.filter(Move.geokret_id == geokret_id).order_by(Move.moved_on_datetime.asc())
-    geokret = Geokret.query.get(geokret_id)
+    moves = session.query(Move) \
+        .filter(Move.geokret_id == geokret_id) \
+        .order_by(Move.moved_on_datetime.asc()) \
+        .all()
+    # moves = Move.query.filter(Move.geokret_id == geokret_id).order_by(Move.moved_on_datetime.asc())
+    geokret = session.query(Geokret) \
+        .get(geokret_id)
 
     last = None
     total_distance = 0
@@ -74,10 +79,11 @@ def update_move_distances(geokret_id):
     geokret.distance = total_distance
 
 
-def update_move_country_and_altitude(move_id):
+def update_move_country_and_altitude(session, move_id):
     """ Obtain and update country and altitude of a move
     """
-    move = Move.query.get(move_id)
+    move = session.query(Move) \
+        .get(move_id)
 
     if move.latitude is not None and move.longitude is not None:
         response = requests.get(
@@ -98,27 +104,29 @@ def update_move_country_and_altitude(move_id):
         move.altitude = -32768
 
 
-def update_geokret_total_moves_count(geokret_id):
+def update_geokret_total_moves_count(session, geokret_id):
     """ Update GeoKret total move count
     """
-    moves = Move.query \
+    moves = session.query(Move) \
         .filter(Move.geokret_id == geokret_id) \
         .filter(Move.type.in_((MOVE_TYPE_DROPPED, MOVE_TYPE_SEEN, MOVE_TYPE_DIPPED))) \
         .order_by(Move.moved_on_datetime.desc())
 
-    geokret = Geokret.query.get(geokret_id)
+    geokret = session.query(Geokret) \
+        .get(geokret_id)
     geokret.caches_count = moves.count()
 
 
-def update_geokret_holder(geokret_id):
+def update_geokret_holder(session, geokret_id):
     """ Update GeoKret holder
     """
-    moves = Move.query \
+    moves = session.query(Move) \
         .filter(Move.geokret_id == geokret_id) \
         .filter(Move.type != MOVE_TYPE_COMMENT) \
         .order_by(Move.moved_on_datetime.desc())
 
-    geokret = Geokret.query.get(geokret_id)
+    geokret = session.query(Geokret) \
+        .get(geokret_id)
 
     geokret.holder_id = None
     if moves.count():
@@ -130,11 +138,12 @@ def update_geokret_holder(geokret_id):
                 break
 
 
-def update_geokret_missing(geokret):
+def update_geokret_missing(session, geokret):
     """ Update GeoKret missing status
     """
     if not isinstance(geokret, Geokret):
-        geokret = Geokret.query.get(geokret)
+        geokret = session.query(Geokret) \
+            .get(geokret)
 
     if geokret.last_position is not None:
         for comment in geokret.last_position.comments:
@@ -144,11 +153,11 @@ def update_geokret_missing(geokret):
     geokret.missing = False
 
 
-def update_move_comments_type(move_id):
+def update_move_comments_type(session, move_id):
     """ Convert move comment type to comment when necessary
     """
-    move = Move.query.get(move_id)
+    move = session.query(Move) \
+        .get(move_id)
     if move.type in (MOVE_TYPE_DIPPED, MOVE_TYPE_COMMENT, MOVE_TYPE_GRABBED, MOVE_TYPE_ARCHIVED):
         for comment in move.comments:
             comment.type = MOVE_COMMENT_TYPE_COMMENT
-    # session.add(move)

requirements.dev.txt

@@ -2,3 +2,5 @@
 nose>=1.3.7,<2
 nose-watcher==0.1.3
 coverage==4.5.2
+mixer==6.1.3
+responses==0.10.5

setup.py

@@ -5,7 +5,7 @@
 
 setuptools.setup(
     name="geokrety_api_models",
-    version="0.0.2",
+    version="0.0.3",
     author="Mathieu Alorent",
     author_email="kumy@geokrety.org",
     description="The GeoKrety API ORM",

tests/__init__.py

@@ -1,10 +1,12 @@
 import os
 import unittest
 
+from mixer.backend.sqlalchemy import Mixer
 from sqlalchemy.engine import create_engine
 from sqlalchemy.orm.session import Session
 
 from geokrety_api_models.base import Base
+from .mixins.responses_mixin import ResponsesMixin
 
 
 def setup_module():
@@ -26,11 +28,15 @@ def teardown_module():
     engine.dispose()
 
 
-class DatabaseTest(unittest.TestCase):
+class DatabaseTest(ResponsesMixin, unittest.TestCase):
     def setUp(self):
+        super(DatabaseTest, self).setUp()
         self.__transaction = connection.begin_nested()
         self.session = Session(connection)
 
+        self.mixer = Mixer(session=self.session, commit=True)
+
     def tearDown(self):
+        super(DatabaseTest, self).tearDown()
         self.session.close()
         self.__transaction.rollback()