* more tests

* updated balances processor to pass test scenarios
* some refactoring and updates

Author: jcuna

README.md

@@ -1,3 +1,4 @@
 # Roomanize
 
-* Create `db` dir inside api dir for dev. Make sur no .DS_Store or hidden files are inside. It must be empty
+* Create `db` dir inside api dir for dev. Make sure no .DS_Store or hidden files are inside. It must be empty
+* Run Tests `./service.sh test --flags -x` # -x stops after first failure. https://docs.pytest.org/en/latest/

api/core/crons/balances.py

@@ -1,8 +1,11 @@
 from datetime import datetime, timedelta, time as d_time
+from logging import Logger
 from time import time
 from dateutil.relativedelta import *
 import sqlalchemy
 from sqlalchemy.orm import joinedload, load_only, defer
+from sqlalchemy.sql import functions
+
 from config.constants import *
 from core import get_logger
 from dal import db
@@ -24,18 +27,13 @@ def balances_cron():
         yesterday = today - timedelta(days=1)
         five_days_ago = yesterday - timedelta(days=5)
 
+        balances = Balance.query.options(joinedload('agreement'), joinedload('payments')).filter(
+            Balance.due_date.between(five_days_ago, yesterday),
+            Balance.id.in_(db.session.query(functions.max(Balance.id)).group_by(Balance.agreement_id).subquery())
+        )
+
         try:
-            agreements = RentalAgreement.query.options(
-                joinedload('balances'), joinedload('balances.payments'), joinedload('interval')).filter(
-                RentalAgreement.terminated_on.is_(None)).filter(RentalAgreement.id.notin_(
-                    Balance.query.options(
-                        defer(Balance.id),
-                        load_only(Balance.agreement_id)
-                    ).filter(Balance.due_date >= today).subquery()))\
-                .join(Balance).filter(
-                (Balance.due_date.between(five_days_ago, yesterday)))
-
-            process_agreements(agreements.all(), logger, yesterday, five_days_ago)
+            process_agreements(balances.all(), logger, yesterday, five_days_ago)
 
         except (sqlalchemy.exc.OperationalError, Exception) as e:
             logger.error('^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^')
@@ -45,57 +43,43 @@ def balances_cron():
         logger.info('Took: ' + str(timedelta(seconds=(time() - start))))
 
 
-def process_agreements(agreements, logger, yesterday: datetime, five_days_ago: datetime):
-    from config import debug
-    debug()
-
-    agreement: RentalAgreement
-    for agreement in agreements:
-        if len(agreement.balances) > 0:
-
-            cycle_balance: Balance
-            for cycle_balance in agreement.balances:
-
-                if (cycle_balance.created_on >= five_days_ago and cycle_balance.init_processed) or \
-                   cycle_balance.due_date <= five_days_ago or cycle_balance.due_date > yesterday:
-
-                    logger.info('Skipping balance ' + str(cycle_balance.id) + ' for aggrement ' + str(agreement.id) +
-                                ' since it was created within the last 5 days and has been init_processed.')
-                    continue
+def process_agreements(balances: list, logger: Logger, yesterday: datetime, five_days_ago: datetime):
+    # this should only contain distinct values
+    agreement_ids = []
+    cycle_balance: Balance
+    for cycle_balance in balances:
 
-                logger.info('Processing agreement id: ' + str(agreement.id))
+        assert cycle_balance.agreement_id not in agreement_ids
 
-                if not cycle_balance.init_processed:
-                    cycle_balance.init_processed = True
+        logger.info('Processing agreement id: ' + str(cycle_balance.agreement_id))
 
-                payments = sum(map(lambda b: b.amount, cycle_balance.payments))
+        payments = sum(map(lambda b: b.amount, cycle_balance.payments))
 
-                logger.info(str(len(cycle_balance.payments)) + ' Payments processed Total:' + str(payments))
+        logger.info(str(len(cycle_balance.payments)) + ' Payments processed Total:' + str(payments))
 
-                previous_balance = cycle_balance.balance - payments
-                new_balance = previous_balance + agreement.rate
+        previous_balance = cycle_balance.balance - payments
+        new_balance = previous_balance + cycle_balance.agreement.rate
 
-                logger.info('Previous balance: ' + str(previous_balance) + ' | New balance: ' + str(new_balance))
+        logger.info('Previous balance: ' + str(previous_balance) + ' | New balance: ' + str(new_balance))
 
-                if agreement.interval.interval == SEMANAL:
-                    delta = timedelta(weeks=1)
-                elif agreement.interval.interval == QUINCENAL:
-                    delta = timedelta(days=14)
-                else:
-                    delta = relativedelta(months=1)
+        if cycle_balance.agreement.interval.interval == SEMANAL:
+            delta = timedelta(weeks=1)
+        elif cycle_balance.agreement.interval.interval == QUINCENAL:
+            delta = timedelta(days=14)
+        else:
+            delta = relativedelta(months=1)
 
-                new_cycle_balance = Balance(
-                    agreement=agreement,
-                    balance=new_balance,
-                    previous_balance=previous_balance,
-                    due_date=cycle_balance.due_date + delta,
-                    init_processed=True,
-                )
-                logger.info('Agreement entered on: ' + str(agreement.entered_on))
-                logger.info('Pay cycle: ' + agreement.interval.interval)
-                logger.info('Last due date: ' + str(cycle_balance.due_date))
-                logger.info('Next due date: ' + str(new_cycle_balance.due_date))
+        new_cycle_balance = Balance(
+            agreement=cycle_balance.agreement,
+            balance=new_balance,
+            previous_balance=previous_balance,
+            due_date=cycle_balance.due_date + delta,
+        )
+        logger.info('Agreement entered on: ' + str(cycle_balance.agreement.entered_on))
+        logger.info('Pay cycle: ' + cycle_balance.agreement.interval.interval)
+        logger.info('Last due date: ' + str(cycle_balance.due_date))
+        logger.info('Next due date: ' + str(new_cycle_balance.due_date))
 
-                db.session.add(new_cycle_balance)
+        db.session.add(new_cycle_balance)
 
     db.session.commit()

api/core/utils.py

@@ -24,7 +24,7 @@ def configure_loggers(app: Flask):
         db_logging.handlers = get_logger('sql', level).handlers
 
 
-def get_logger(name: str = 'app', level: int = logging.INFO):
+def get_logger(name: str = 'app', level: int = logging.INFO) -> logging.Logger:
     """
     return a logger with default settings
 
@@ -53,26 +53,6 @@ def get_logger(name: str = 'app', level: int = logging.INFO):
     return logger
 
 
-class Lock:
-    """
-    handy class to create a lock file
-    use it like lock = Lock('file')
-    with lock:
-        # run things
-    """
-
-    def __init__(self, lock_file):
-        self.lock_file = lock_file
-        # raise exception if pid file exists and log it. remove if it's stale
-
-    def __enter__(self):
-        # write pid file
-        pass
-
-    def __exit__(self, type, value, traceback):
-        # remove pid file
-        pass
-
 
 def local_to_utc(date: str) -> datetime:
     """

api/dal/models.py

@@ -207,13 +207,13 @@ class RentalAgreement(db.Model, ModelIter):
     room_id = db.Column(BigInteger, db.ForeignKey('rooms.id'), index=True, nullable=False)
     project_id = db.Column(BigInteger, db.ForeignKey('projects.id'), index=True, nullable=False)
     time_interval_id = db.Column(db.Integer, db.ForeignKey('time_intervals.id'), nullable=False)
-    rate = db.Column(db.DECIMAL(10, 2), nullable=False)
-    deposit = db.Column(db.DECIMAL(10, 2), nullable=False)
+    rate = db.Column(db.Numeric(10, 2), nullable=False)
+    deposit = db.Column(db.Numeric(10, 2), nullable=False)
     created_on = db.Column('created_on', db.DateTime(), nullable=False, default=datetime.utcnow)
     entered_on = db.Column(db.DateTime(), nullable=False)
     terminated_on = db.Column(db.DateTime())
 
-    tenant_history = relationship(TenantHistory, uselist=False, back_populates='rental_agreement')
+    tenant_history = relationship(TenantHistory, uselist=False, back_populates='rental_agreement', cascade='all, delete')
     room = relationship('Room', uselist=False)
     project = relationship(Project, uselist=False)
     interval = relationship(TimeInterval, uselist=False)
@@ -258,14 +258,13 @@ class Balance(db.Model, ModelIter):
 
     id = db.Column(BigInteger, primary_key=True)
     agreement_id = db.Column(BigInteger, db.ForeignKey('rental_agreements.id'), index=True)
-    balance = db.Column(db.DECIMAL(10, 2), nullable=False)
-    previous_balance = db.Column(db.DECIMAL(10, 2), nullable=False)
+    balance = db.Column(db.Numeric(10, 2), nullable=False)
+    previous_balance = db.Column(db.Numeric(10, 2), nullable=False)
     created_on = db.Column(db.DateTime(), nullable=False, index=True, default=datetime.utcnow)
     due_date = db.Column(db.DateTime(), nullable=False, index=True)
-    init_processed = db.Column(db.Boolean(), nullable=False, default=False)
 
-    agreement = relationship(RentalAgreement, uselist=False, backref='balances')
-    payments = relationship('Payment', backref='balances')
+    agreement = relationship(RentalAgreement, uselist=False, backref='balances', cascade='all, delete')
+    payments = relationship('Payment', backref='balances', cascade='all, delete')
 
 
 class PaymentType(db.Model, ModelIter):
@@ -280,7 +279,7 @@ class Payment(db.Model, ModelIter):
 
     id = db.Column(BigInteger, Sequence('payments_id_seq', start=1000, increment=1), primary_key=True)
     balance_id = db.Column(BigInteger, db.ForeignKey('balances.id'), index=True)
-    amount = db.Column(db.DECIMAL(10, 2), nullable=False)
+    amount = db.Column(db.Numeric(10, 2), nullable=False)
     paid_date = db.Column(db.DateTime(), nullable=False, index=True, default=datetime.utcnow)
     payment_type_id = db.Column(db.Integer, db.ForeignKey('payment_types.id'), nullable=False)
 
@@ -297,7 +296,7 @@ class Expense(db.Model, ModelIter):
 
     id = db.Column(BigInteger, primary_key=True)
     project_id = db.Column(BigInteger, db.ForeignKey('projects.id'), index=True, nullable=False)
-    amount = db.Column(db.DECIMAL(10, 2), nullable=False)
+    amount = db.Column(db.Numeric(10, 2), nullable=False)
     description = db.Column(db.String(512), nullable=False)
     input_date = db.Column(db.DateTime(), nullable=False, default=datetime.utcnow)
     expense_date = db.Column(db.DateTime(), nullable=False, index=True, default=datetime.utcnow)

api/job_runner.py

@@ -31,9 +31,9 @@
 }
 
 registration_sample = {
-    'date': front_end_date(),
+    'date': front_end_date(), # defaults to today
     'deposit': '4400.00',
-    'interval': '100',
+    'interval': '100', # weekly, 200 every two weeks and 400 monthly
     'rate': '1500.00',
     'reference1': '5555555555',
     'reference2': '',
@@ -52,33 +52,41 @@ def seed_project(client: FlaskClient, token: str):
     }
     return client.post(endpoint('/projects'), json=project_sample, headers=auth)
 
-def seed_room(client: FlaskClient, token: str, overrides: dict):
+def seed_room(client: FlaskClient, token: str, override=None):
     auth = {
         'X-Access-Token': token
     }
 
     data = {}
     data.update(room_sample)
-    data.update(overrides)
+    if override:
+        data.update(override)
 
     return client.post(endpoint('/rooms'), json=data, headers=auth)
 
 
-def seed_tenant(client: FlaskClient, token: str):
+def seed_tenant(client: FlaskClient, token: str, override=None):
     auth = {
         'X-Access-Token': token
     }
+    data = {}
+    data.update(tenant_sample)
+    if override:
+        data.update(override)
 
-    return client.post(endpoint('/tenants'), json=tenant_sample, headers=auth)
+    return client.post(endpoint('/tenants'), json=data, headers=auth)
 
 
-def seed_new_agreement(client: FlaskClient, token: str, overrides: dict):
+def seed_new_agreement(client: FlaskClient, token: str, override=None):
 
+    if override is None:
+        override = dict()
     auth = {
         'X-Access-Token': token
     }
     data = {}
     data.update(registration_sample)
-    data.update(overrides)
+    if override:
+        data.update(override)
 
     return client.post(endpoint('/agreements'), json=data, headers=auth)