tests running

Author: marcidy

.flaskenv

@@ -1,3 +1,4 @@
-YOURAPPLICATION_SETTINGS=/home/marcidy/projects/noisebridge/donate2/donate.cfg
-FLASK_APP=donate
+APPLICATION_SETTINGS=/home/marcidy/projects/noisebridge/new_donate/donate.cfg
+FLASK_APP=/home/marcidy/projects/noisebridge/new_donate/autoapp.py
 FLASK_ENV=development
+FLASK_DEBUG=1

autoapp.py

@@ -0,0 +1,7 @@
+from flask.helpers import get_debug_flag
+from donate.appp import create_app
+from donate.setting import DevConfig, ProdConfig
+
+CONFIG = DevConfig if get_debug_flag() else ProdConfig
+
+app = create_app(CONFIG)

donate.cfg

@@ -3,6 +3,6 @@ FLASK_ENV = 'development'
 # FLASK_ENV = 'production'
 
 SQLALCHEMY_TRACK_MODIFICATIONS = False
-SQLALCHEMY_DATABASE_URI='sqlite:////home/marcidy/projects/noisebridge/donate2/donate.db'
+SQLALCHEMY_DATABASE_URI='sqlite:////home/marcidy/projects/noisebridge/new_donate/donate.db'
 SECRET_KEY = 'dev'
 

donate/__init__.py

@@ -1,38 +0,0 @@
-import os
-from flask import Flask
-from flask_sqlalchemy import SQLAlchemy
-from flask_migrate import Migrate
-from donate.database import db
-
-
-def load_models():
-    from donate import models
-
-
-load_models()
-
-
-def create_app(test_config=None):
-
-    app = Flask(__name__, instance_relative_config=True)
-    app.config.from_envvar('YOURAPPLICATION_SETTINGS')
-
-    db.init_app(app)
-    db.app = app
-    Migrate(app, db)
-
-    if test_config is None:
-        app.config.from_pyfile('config.py', silent=True)
-    else:
-        app.config.from_mapping(test_config)
-
-    try:
-        os.makedirs(app.instance_path)
-    except OSError:
-        pass
-
-    @app.route('/home')
-    def hello():
-        return('donate2')
-
-    return(app)

donate/app.py

@@ -0,0 +1,42 @@
+import os
+from flask import Flask
+from donate.extensions import db, migrate
+from donate.settings import ProdConfig
+from donate.models import (
+    User,
+    Account,
+    Project,
+    Currency,
+    Transaction,
+)
+
+
+def create_app(config_object=ProdConfig):
+
+    app = Flask(__name__.split('.')[0])
+    app.url_map.strict_slashes = False
+    app.config.from_object(config_object)
+
+    register_extensions(app)
+    register_shellcontext(app)
+
+    return(app)
+
+
+def register_extensions(app):
+    db.init_app(app)
+    migrate.init_app(app, db)
+
+
+def register_shellcontext(app):
+    def shell_context():
+        return{
+            'db': db,
+            'user': User,
+            'account': Account,
+            'project': Project,
+            'ccy': Currency,
+            'tx': Transaction
+        }
+
+    app.shell_context_processor(shell_context)

donate/database.py

@@ -1,4 +1,6 @@
-from flask_sqlalchemy import SQLAlchemy
+from sqlalchemy.orm import relationship
+from .extensions import db
 
-
-db = SQLAlchemy()
+Column = db.Column
+relationship = relationship
+Model = db.Model

donate/extensions.py

@@ -0,0 +1,6 @@
+from flask_sqlalchemy import SQLAlchemy, Model
+from flask_migrate import Migrate
+
+
+db = SQLAlchemy()
+migrate = Migrate()

donate/models.py

@@ -1,8 +1,24 @@
-from donate.database import db
+from donate.extensions import db
 from datetime import datetime
+from flask_validator import (
+    ValidateInteger,
+    ValidateString,
+    ValidateEmail,
+    ValidateNumeric,
+)
 
 
 class User(db.Model):
+    '''A user is someonme internal to Noisebridge who uses the system for
+    reportinng purposes.  This should include treasurers and priviledged
+    users who may access sensitive user data for donations
+
+    id:         unique ID of the user, e.g. primary key
+    username:   name internal to the system
+    slack:      slack handle
+    email:      email address of user
+    '''
+
     id = db.Column(db.Integer, primary_key=True)
     username = db.Column(db.String(80), unique=True, nullable=False)
     slack = db.Column(db.String(80), unique=True, nullable=False)
@@ -11,16 +27,40 @@ class User(db.Model):
     def __repr__(self):
         return('<User {}>'.format(self.username))
 
+    @classmethod
+    def __declare_last__(cls):
+        ValidateString(User.username, False, True)
+        ValidateString(User.slack, False, True)
+        ValidateEmail(User.email,
+                      False,
+                      True,
+                      "not a valid email address")
+
 
 class Transaction(db.Model):
+    ''' A transaction moves amounts between accounts.  When a transaction
+    occurs, an account must be debited and an account must be credited.
+
+    id:             unique ID of transaction
+    amount:         the quantity of the transaction, e.g. <X> USD or <Y> BTC.
+    ccy:            the denomiation of the transaction, e.g. 100 <CCY>
+    datetime:       the time of the transaction in epochs
+    payer_id:       The account which will be debited
+    recvr_id:       the account which will be credited
+    requestor_id:   The user who is requesting the transfer
+    approver_id:    The user approving the transfoer
+    pay_from_acct:  Account linked to the payer_id
+    rec_to_acct:    Account linked to recvr_id
+    '''
+
     id = db.Column(db.Integer, primary_key=True)
     amount = db.Column(db.Float, nullable=False)
     ccy = db.Column(db.Integer, db.ForeignKey('currency.id'))
     datetime = db.Column(db.DateTime, nullable=False, default=datetime.utcnow)
     payer_id = db.Column(db.Integer,
                          db.ForeignKey('account.id'),
                          nullable=False)
-    recer_id = db.Column(db.Integer,
+    recvr_id = db.Column(db.Integer,
                          db.ForeignKey('account.id'),
                          nullable=False)
     requestor_id = db.Column(db.Integer,
@@ -31,26 +71,74 @@ class Transaction(db.Model):
                             nullable=False)
 
     pay_from_acct = db.relationship('Account', foreign_keys=[payer_id])
-    rec_to_acct = db.relationship('Account', foreign_keys=[recer_id])
+    rec_to_acct = db.relationship('Account', foreign_keys=[recvr_id])
+
+    @classmethod
+    def __declare_last__(cls):
+        ValidateInteger(Transaction.ccy, False, True)
+        ValidateNumeric(Transaction.amount, False, True)
+        ValidateInteger(Transaction.payer_id, False, True)
+        ValidateInteger(Transaction.recvr_id, False, True)
+        ValidateInteger(Transaction.requestor_id, False, True)
+        ValidateInteger(Transaction.approver_id, False, True)
 
 
 class Account(db.Model):
+    ''' Accounts aggregate transactions.  They are associated with one and
+    only one currenct.  An account can increase or decrease based on the
+    sum of the transactions.
+
+    id:     unique Id
+    name:   name or nmenonic of account
+    tx_ids: transactions associated with account.  Must link to pay/rec to
+            get debit or credit info
+    ccy:    account denomination e.g. USD or BTC.
+    '''
+
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(120), unique=True, nullable=False)
     tx_ids = db.Column(db.Integer, db.ForeignKey('transaction.id'))
     ccy = db.Column(db.Integer, db.ForeignKey('currency.id'))
 
+    @classmethod
+    def __declare_last__(cls):
+        ValidateString(Account.name, False, True)
+        ValidateInteger(Account.tx_ids, False, True)
+        ValidateInteger(Account.ccy, False, True)
+
 
 class Project(db.Model):
+    ''' A project has a specific goal, e.g. amount to be reached. It is
+    linked to an account which provides information about how much has been
+    donated towards the goal.
+
+    id:         Unique ID
+    name:       Project name
+    account_id: Accunt linked to project (might need multiple for multiple ccys
+    goal:       Amount required to read the goal of the project.
+                (prob need ccy)
+    '''
+
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(120), unique=True, nullable=False)
     account_id = db.Column(db.Integer,
                            db.ForeignKey('account.id'),
                            nullable=False)
     goal = db.Column(db.Float, nullable=False, default=0)
 
+    @classmethod
+    def __declare_last__(cls):
+        ValidateString(Project.name, False, True)
+        ValidateInteger(Project.account_id, False, True)
+        ValidateNumeric(Project.goal, False, True)
+
 
 class Currency(db.Model):
     id = db.Column(db.Integer, primary_key=True)
     name = db.Column(db.String(120), unique=True, nullable=False)
     code = db.Column(db.String(3), unique=True, nullable=False)
+
+    @classmethod
+    def __declare_last__(cls):
+        ValidateString(Currency.name, False, True)
+        ValidateString(Currency.code, False, True)

donate/settings.py

@@ -0,0 +1,46 @@
+import os
+from datetime import timedelta
+
+
+class Config:
+    """ Base Configuration """
+
+    SECRET_KEY = os.environ.get('DONATE_SECRET', 'key')
+    APP_DIR = os.path.abspath(os.path.dirname(__file__))
+    PROJECT_ROOT = os.path.abspath(os.path.join(APP_DIR, os.pardir))
+    DEBUG_TB_INTERCEPT_REDIRECTS = False
+    CACHE_TYPE = 'simple'
+    SQLALCHEMY_TRACK_MODIFICAITONS = False
+    JWT_AUTH_USERNAME_KEY = 'email'
+    JWT_AUTH_HEADERS_PREFIX = 'Token'
+    CORS_ORIGIN_WHITELIST = []
+    JWT_HEADER_TYPE = 'Token'
+
+
+class ProdConfig(Config):
+    """ Production Configuration """
+
+    ENV = 'prod'
+    DEBUG = False
+    SQLALCHEMY_DATABASE_URI = os.environ.get('DATABASE_URL',
+                                             'postresql://localhost/example')
+
+
+class DevConfig(Config):
+    """ Development Configuration """
+
+    ENV = 'dev'
+    DEBUG = True
+    DB_NAME = 'dev.db'
+    DB_PATH = os.path.join(Config.PROJECT_ROOT, DB_NAME)
+    SQLALCHEMY_DATABASE_URI = 'sqlite:////{0}'.format(DB_PATH)
+    CACHE_TYPE = 'simple'
+    JWT_ACCESS_TOKEN_EXPIRES = timedelta(10**6)
+
+
+class TestConfig(Config):
+    """ Testing Configuration """
+
+    TESTING = True
+    DEBUG = True
+    SQLALCHEMY_DATABASE_URI = 'sqlite://'

migrations/__pycache__/env.cpython-35.pyc

@@ -4,11 +4,6 @@
 from logging.config import fileConfig
 import logging
 
-from flask import current_app
-
-from donate.database import db
-from donate import create_app
-
 # this is the Alembic Config object, which provides
 # access to the values within the .ini file in use.
 config = context.config
@@ -20,15 +15,21 @@
 
 # add your model's MetaData object here
 # for 'autogenerate' support
-# from myapp import mymodel
-# target_metadata = mymodel.Base.metadata
+from donate.models import (
+    User,
+    Currency,
+    Account,
+    Project,
+    Transaction,
+)
+from donate import db
 
-app = create_app()
+target_metadata = db.Model.metadata
 
+from flask import current_app
 config.set_main_option('sqlalchemy.url',
                        current_app.config.get('SQLALCHEMY_DATABASE_URI'))
 # target_metadata = current_app.extensions['migrate'].db.metadata
-target_metadata = db.metadata
 
 # other values from the config, defined by the needs of env.py,
 # can be acquired:
@@ -86,10 +87,12 @@ def process_revision_directives(context, revision, directives):
     try:
         with context.begin_transaction():
             context.run_migrations()
+    except Exception as exception:
+        logger.error(exception)
+        raise exception
     finally:
         connection.close()
 
-
 if context.is_offline_mode():
     run_migrations_offline()
 else: