diff --git a/app/__init__.py b/app/__init__.py
index da6671a980d14eaa65057e149c9dbeb33b3874d6..dc103fa2f517a1a3731ecb86483afcd5e3ad0cbd 100644
--- a/app/__init__.py
+++ b/app/__init__.py
@@ -1,3 +1,4 @@
+"""BP flask microservices"""
 import logging
 from logging.handlers import RotatingFileHandler
 from flask import Flask
@@ -6,6 +7,7 @@ MEGABYTE = 10**6
 LOG_FORMAT = '[%(asctime)s] %(pathname)s:%(lineno)d %(levelname)s - %(message)s'
 LOG_PATH = '/var/log/flask.log'
 
+
 def create_app(config):
     """Set up the application."""
     app = Flask(__name__)
@@ -22,25 +24,15 @@ def create_app(config):
 
     app.logger.info('Setting up application...')
 
-    from .lib import database
-    database.register(app)
-
-    from .lib import red
-    red.register(app)
-
     from . import views
     views.register(app)
 
-    from .lib import exceptions
-    exceptions.register(app)
-
-    from .lib import service
-    service.register(app)
-
-    from .lib import session
-    session.register(app)
+    from app.lib import database, red, exceptions, service, session, auth0
+    services = (database, red, exceptions, service, session, auth0)
+    for service in services:
+        service.register(app)
 
-    with app.app_context():
-        database.db.create_all()
+    # with app.app_context():
+    #     database.db.create_all()
 
     return app
diff --git a/app/config/development.default.py b/app/config/development.default.py
index 9333a24793cb3d59eb8212f2f54ca803c4f9dbb0..18a4f9e357d3aae0464a011adc3b86e4aa10d3f8 100644
--- a/app/config/development.default.py
+++ b/app/config/development.default.py
@@ -28,6 +28,8 @@ AUTH0_AUTH_HEADER = 'x-blocpower-auth0-token'
 AUTH0_DOMAIN = os.environ['AUTH0_DOMAIN']
 AUTH0_AUDIENCE = os.environ['AUTH0_AUDIENCE']
 AUTH0_CLAIMS_NAMESPACE = os.environ['AUTH0_CLAIMS_NAMESPACE']
+AUTH0_CLIENT_ID = os.environ['AUTH0_CLIENT_ID']
+AUTH0_CLIENT_SECRET = os.environ['AUTH0_CLIENT_SECRET']
 
 # Blocpower auth information.
 HEADER_AUTH_KEY = 'x-blocpower-auth-key'
diff --git a/app/config/local.default.py b/app/config/local.default.py
index d3e4d2b360c3600a01e46b3a2a574af7738bed76..41819cb12b9e78ec10c509551927fc69f212b30c 100644
--- a/app/config/local.default.py
+++ b/app/config/local.default.py
@@ -25,6 +25,8 @@ AUTH0_AUTH_HEADER = 'x-blocpower-auth0-token'
 AUTH0_DOMAIN = '$AUTH0_DOMAIN'
 AUTH0_AUDIENCE = '$AUTH0_AUDIENCE'
 AUTH0_CLAIMS_NAMESPACE = '$AUTH0_CLAIMS_NAMESPACE'
+AUTH0_CLIENT_ID = '$AUTH0_CLIENT_ID'
+AUTH0_CLIENT_SECRET = '$AUTH0_CLIENT_SECRET'
 
 # Blocpower auth information.
 HEADER_AUTH_KEY = 'x-blocpower-auth-key'
diff --git a/app/config/production.default.py b/app/config/production.default.py
index b382b44461d2f37932baa629bf01c8d513fc5b56..74fbbb2691fb38d49bf4a7fe637953885ae875c8 100644
--- a/app/config/production.default.py
+++ b/app/config/production.default.py
@@ -28,6 +28,8 @@ AUTH0_AUTH_HEADER = 'x-blocpower-auth0-token'
 AUTH0_DOMAIN = os.environ['AUTH0_DOMAIN']
 AUTH0_AUDIENCE = os.environ['AUTH0_AUDIENCE']
 AUTH0_CLAIMS_NAMESPACE = os.environ['AUTH0_CLAIMS_NAMESPACE']
+AUTH0_CLIENT_ID = os.environ['AUTH0_CLIENT_ID']
+AUTH0_CLIENT_SECRET = os.environ['AUTH0_CLIENT_SECRET']
 
 # Blocpower auth information.
 HEADER_AUTH_KEY = 'x-blocpower-auth-key'
diff --git a/app/config/staging.default.py b/app/config/staging.default.py
index c8a4b818e89c9522ed616ad228524e55c999b844..1e82cec2bd5b6b39c71a85ef0eebfe297f745da4 100644
--- a/app/config/staging.default.py
+++ b/app/config/staging.default.py
@@ -28,6 +28,8 @@ AUTH0_AUTH_HEADER = 'x-blocpower-auth0-token'
 AUTH0_DOMAIN = os.environ['AUTH0_DOMAIN']
 AUTH0_AUDIENCE = os.environ['AUTH0_AUDIENCE']
 AUTH0_CLAIMS_NAMESPACE = os.environ['AUTH0_CLAIMS_NAMESPACE']
+AUTH0_CLIENT_ID = os.environ['AUTH0_CLIENT_ID']
+AUTH0_CLIENT_SECRET = os.environ['AUTH0_CLIENT_SECRET']
 
 # Blocpower auth information.
 HEADER_AUTH_KEY = 'x-blocpower-auth-key'
diff --git a/app/controllers/base.py b/app/controllers/base.py
index 546e7de59596c0a032f75da7722110b910e9441a..cf86692dd25dcda3e91e3b7f0defdc7a89b4c12b 100644
--- a/app/controllers/base.py
+++ b/app/controllers/base.py
@@ -1,140 +1,12 @@
-from sqlalchemy.exc import IntegrityError
-from werkzeug.datastructures import MultiDict
-from werkzeug.exceptions import NotFound, BadRequest
-from flask import current_app
+"""Flask RestController wrapper"""
+from bpvalve.flask.controllers import RestController as BaseRestController
+from app.lib import db, redis, auth0_
 
-from ..lib.database import db, commit
 
-
-class RestController(object):
-    """A RESTful class for manipulating database objects.
-
-        Controllers should be request-agnostic.  The can be initialized and used
-        outside of a request context.  This provides a convenient place to dump
-        complicated filters or additional data manipulation that happens before
-        or after a database fetch.
+class RestController(BaseRestController):
     """
-    # The model associated with this REST resource.
-    Model = None
-    # A dictionary of available filters on the resource.
-    #
-    # For each key in this dictionary, if the key is present in the dictionary,
-    #   the value associated with that key (a function taking one argument) is
-    #   passed the filter_data dictionary and the return value is used as a
-    #   database filter.  For example,
-    #
-    #       {
-    #           'id_': lambda d: Model.id_ == d['id_']
-    #       }
-    #
-    #   There is no requirement that the filter function only manipulate its
-    #   key, so these filters can be arbitrarily complex as needed.  Multiline
-    #   filters should be defined as separate functions and referenced here.
-    filters = {}
-
-    # The primary  key to use to retrieve the model in get/put/delete requests.
-    key = 'id'
-
-    def query(self, filter_data):
-        """Construct a query for the model.
-
-            Args:
-                filter_data - A dictionary representing the query string
-                    parameters.  This is unused at the moment.
-        """
-        return db.session.query(self.Model)
-
-    def filter(self, q, filter_data):
-        """Parse a dictionary representing the query parameters into database
-            filters.
-
-            q - A SQLAlchemy query.
-            filter_data - A dictionary representing the query string parameters.
-        """
-        for k, f in self.filters.items():
-            if k in filter_data:
-                q = q.filter(f(filter_data))
-
-        if 'order_by' in filter_data:
-            order_by = getattr(self.Model, filter_data['order_by'])
-            sort = ''
-
-            if 'sort' in filter_data:
-                sort = filter_data['sort']
-
-            q = q.order_by('{} {}'.format(order_by, sort))
-
-        if 'limit' in filter_data:
-            q = q.limit(int(filter_data['limit']))
-
-        return q
-
-    def get_form(self, filter_data):
-        """Get the WTForms form for the model."""
-        pass
-
-    def index(self, filter_data):
-        """Get a query for all models matching filter_data."""
-        q = self.query(filter_data)
-        q = self.filter(q, filter_data)
-        return q.all()
-
-    def get(self, id_, filter_data):
-        """Get a single model matching an id."""
-        model = db.session.query(self.Model)\
-            .filter(getattr(self.Model, self.key)==id_).first()
-        if not model:
-            raise NotFound
-        return model
-
-    def create(self, data, filter_data):
-        """Creates a model, but does not add it to the database."""
-        model = self.Model()
-        form = self.get_form(filter_data)(formdata=MultiDict(data))
-
-        if not form.validate():
-            raise BadRequest(form.errors)
-
-        form.populate_obj(model)
-        return model
-
-    def post(self, data, filter_data):
-        """Post a new model from a dictionary."""
-        model = self.create(data, filter_data)
-        db.session.add(model)
-        try:
-            commit()
-        except IntegrityError as e:
-            raise (
-                BadRequest(str(e)) if current_app.config['DEBUG'] else
-                BadRequest)
-
-        return model
-
-    def put(self, id_, data, filter_data):
-        """Change an existing model using an id and dictionary data."""
-        model = self.get(id_, filter_data)
-        form = self.get_form(filter_data)(formdata=MultiDict(data))
-
-        if not str(form.id.data) == str(id_):
-            raise BadRequest(['The id in the model and the uri do not match.'])
-        if not form.validate():
-            raise BadRequest(form.errors)
-
-        form.populate_obj(model)
-        db.session.add(model)
-        try:
-            commit()
-        except IntegrityError as e:
-            raise (
-                BadRequest(str(e)) if current_app.config['DEBUG'] else
-                BadRequest)
-
-        return model
-
-    def delete(self, id_, filter_data):
-        """Delete a model given its id."""
-        model = self.get(id_, filter_data)
-        db.session.delete(model)
-        commit()
-        return {}
+    Wrapper for BaseRestController
+    """
+    db = db
+    redis = redis
+    auth0 = auth0_
diff --git a/app/controllers/building_sensor.py b/app/controllers/building_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..d821317eeac005df977d69335125498557d9194d
--- /dev/null
+++ b/app/controllers/building_sensor.py
@@ -0,0 +1,16 @@
+from .base import RestController
+from ..forms.building_sensor import BuildingSensorForm
+from ..models.building_sensor import BuildingSensor
+
+class BuildingSensorController(RestController):
+    """A sensor controller."""
+    Model = BuildingSensor
+    filters = {
+        'building_id': lambda d: BuildingSensor.building_id == d['building_id'],
+    }
+
+    def get_form(self, filter_data):
+        """Return the sensor form."""
+        return BuildingSensorForm
+
+
diff --git a/app/controllers/building_sensor_apartment_node.py b/app/controllers/building_sensor_apartment_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..1e702820caadae4d1aa8aedd3610248392c9d392
--- /dev/null
+++ b/app/controllers/building_sensor_apartment_node.py
@@ -0,0 +1,14 @@
+from .base import RestController
+from ..forms.building_sensor_apartment_node import BuildingSensorApartmentNodeForm
+from ..models.building_sensor_apartment_node import BuildingSensorApartmentNode
+
+class BuildingSensorApartmentNodeController(RestController):
+    """An apartment node controller."""
+    Model = BuildingSensorApartmentNode
+    filters = {
+        'parent_id': lambda d: BuildingSensorApartmentNode.parent_id == d['parent_id'],
+    }
+
+    def get_form(self, filter_data):
+        """Return the apartment node form."""
+        return BuildingSensorApartmentNodeForm
diff --git a/app/controllers/building_sensor_boiler_node.py b/app/controllers/building_sensor_boiler_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..ffebb37c98610d7795ec5b2b20a5caa47c083d5e
--- /dev/null
+++ b/app/controllers/building_sensor_boiler_node.py
@@ -0,0 +1,14 @@
+from .base import RestController
+from ..forms.building_sensor_boiler_node import BuildingSensorBoilerNodeForm
+from ..models.building_sensor_boiler_node import BuildingSensorBoilerNode
+
+class BuildingSensorBoilerNodeController(RestController):
+    """A boiler node controller."""
+    Model = BuildingSensorBoilerNode
+    filters = {
+        'parent_id': lambda d: BuildingSensorBoilerNode.parent_id == d['parent_id'],
+    }
+
+    def get_form(self, filter_data):
+        """Return the boiler node form."""
+        return BuildingSensorBoilerNodeForm
diff --git a/app/controllers/building_sensor_repeater_node.py b/app/controllers/building_sensor_repeater_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..25d0866cc4af4b9d323c609d79984fcc186e4388
--- /dev/null
+++ b/app/controllers/building_sensor_repeater_node.py
@@ -0,0 +1,14 @@
+from .base import RestController
+from ..forms.building_sensor_repeater_node import BuildingSensorRepeaterNodeForm
+from ..models.building_sensor_repeater_node import BuildingSensorRepeaterNode
+
+class BuildingSensorRepeaterNodeController(RestController):
+    """A repeater node controller."""
+    Model = BuildingSensorRepeaterNode
+    filters = {
+        'parent_id': lambda d: BuildingSensorRepeaterNode.parent_id == d['parent_id'],
+    }
+
+    def get_form(self, filter_data):
+        """Return the repeater node form."""
+        return BuildingSensorRepeaterNodeForm
diff --git a/app/controllers/sensor_image.py b/app/controllers/sensor_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..2f218f500c40fc64f8d630a8693283983f088694
--- /dev/null
+++ b/app/controllers/sensor_image.py
@@ -0,0 +1,17 @@
+from .base import RestController
+from ..forms.sensor_image import SensorImageForm
+from ..models.sensor_image import SensorImage
+
+class SensorImageController(RestController):
+    """A sensor image controller."""
+    Model = SensorImage
+    filters = {
+        'entity_id': lambda d: SensorImage.entity_id == d['entity_id'],
+        'entity_type': lambda d: SensorImage.entity_type == d['entity_type'],
+    }
+
+    def get_form(self, filter_data):
+        """Return the sensor image form."""
+        return SensorImageForm
+
+
diff --git a/app/forms/base.py b/app/forms/base.py
index 8118e9321ae410765aeadb51cf5ef8f14f3065c4..a886f9cfbb23c3331c564e36a26297aca6910381 100644
--- a/app/forms/base.py
+++ b/app/forms/base.py
@@ -9,6 +9,11 @@ class Form(wtf.Form):
     id = wtf.IntegerField()
 
 
+class UserForm:
+    user_created = wtf.StringField(validators=[wtf.validators.Length(max=64)])
+    user_modified = wtf.StringField(validators=[wtf.validators.Length(max=64)])
+
+
 class AddressForm(object):
     """A form for validating address information."""
     street_address = wtf.StringField(
diff --git a/app/forms/building_sensor.py b/app/forms/building_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..9bf2b6d689a16cbceea3fd446d4d6ce3de35b984
--- /dev/null
+++ b/app/forms/building_sensor.py
@@ -0,0 +1,37 @@
+import wtforms as wtf
+from .base import Form, UserForm
+
+class BuildingSensorForm(Form, UserForm):
+    """ A form for validating building sensor requests."""
+
+    id = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    building_id = wtf.IntegerField(
+        validators=[wtf.validators.Required()]
+    )
+    sensor_type = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    date_of_install = wtf.DateField(
+        validators=[wtf.validators.Optional()]
+    )
+    heating_system_type =  wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    gateway_serial =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    gateway_id =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    installer_name =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    placement_type =  wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    notes =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+
diff --git a/app/forms/building_sensor_apartment_node.py b/app/forms/building_sensor_apartment_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..3229dd04c704b3db8e505ace991fd3d474aa5c77
--- /dev/null
+++ b/app/forms/building_sensor_apartment_node.py
@@ -0,0 +1,45 @@
+import wtforms as wtf
+from .base import Form, UserForm
+
+class BuildingSensorApartmentNodeForm(Form, UserForm):
+    """ A form for validating apartment node requests."""
+
+    id = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    parent_id = wtf.IntegerField(
+        validators=[wtf.validators.Required()]
+    )
+    node_id = wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    node_location =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    apartment_number =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    apartment_floor =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    number_of_bedrooms =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    tenant_name =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    tenant_contact =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    apartment_orientation = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    node_wall_type =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    tenant_heating_issue =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    notes =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
diff --git a/app/forms/building_sensor_boiler_node.py b/app/forms/building_sensor_boiler_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..c919b4339de10cdec95e0a765b38be3902e129c5
--- /dev/null
+++ b/app/forms/building_sensor_boiler_node.py
@@ -0,0 +1,33 @@
+import wtforms as wtf
+from .base import Form, UserForm
+
+class BuildingSensorBoilerNodeForm(Form, UserForm):
+    """ A form for validating boiler node requests."""
+
+    id = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    parent_id = wtf.IntegerField(
+        validators=[wtf.validators.Required()]
+    )
+    node_id = wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    node_location = wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    temperature_probe_1 = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    temperature_probe_2 = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    temperature_probe_3 = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    temperature_probe_4 = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    notes =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
diff --git a/app/forms/building_sensor_repeater_node.py b/app/forms/building_sensor_repeater_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..4421d939bfad447510ee0257a5cd1af16df4347b
--- /dev/null
+++ b/app/forms/building_sensor_repeater_node.py
@@ -0,0 +1,24 @@
+import wtforms as wtf
+from .base import Form, UserForm
+
+class BuildingSensorRepeaterNodeForm(Form, UserForm):
+    """ A form for validating repeater node requests."""
+
+    id = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    parent_id = wtf.IntegerField(
+        validators=[wtf.validators.Required()]
+    )
+    node_id = wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    node_location = wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    apartment_floor = wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
+    notes =  wtf.StringField(
+        validators=[wtf.validators.Optional()]
+    )
diff --git a/app/forms/sensor_image.py b/app/forms/sensor_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f997156d512d2912df8f73536a02179527a2c8e
--- /dev/null
+++ b/app/forms/sensor_image.py
@@ -0,0 +1,21 @@
+import wtforms as wtf
+from .base import Form, UserForm
+
+class SensorImageForm(Form, UserForm):
+    """ A form for validating sensor image requests."""
+
+    id = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
+    entity_id = wtf.IntegerField(
+        validators=[wtf.validators.Required()]
+    )
+    entity_type = wtf.IntegerField(
+        validators=[wtf.validators.Required()]
+    )
+    image_type = wtf.IntegerField(
+        validators=[wtf.validators.Required()]
+    )
+    box_id = wtf.IntegerField(
+        validators=[wtf.validators.Optional()]
+    )
diff --git a/app/lib/__init__.py b/app/lib/__init__.py
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..3fac2006f832124ac650884f896339cd69d51619 100644
--- a/app/lib/__init__.py
+++ b/app/lib/__init__.py
@@ -0,0 +1,3 @@
+from .database import db
+from .red import redis
+from .auth0 import auth0_
diff --git a/app/lib/auth0.py b/app/lib/auth0.py
new file mode 100644
index 0000000000000000000000000000000000000000..3014a0a877acf02778d047e4944312048c488128
--- /dev/null
+++ b/app/lib/auth0.py
@@ -0,0 +1,19 @@
+from bpvalve.auth0 import Auth0Wrapper
+
+
+class FlaskAuth0:
+    """Initilalization class for Auth0Wrapper"""
+
+    def init_app(self, app):
+        """Intialize Auth0Wrapper"""
+        self.auth = Auth0Wrapper(app.config.get('AUTH0_DOMAIN'),
+                                 app.config.get('AUTH0_CLIENT_ID'),
+                                 app.config.get('AUTH0_CLIENT_SECRET'),
+                                 'https://{}/api/v2/'.format(app.config.get('AUTH0_DOMAIN')))
+
+auth0_ = FlaskAuth0()
+
+
+def register(app):
+    """Configure the Auth0Wrapper based on the app configuration."""
+    auth0_.init_app(app)
diff --git a/app/lib/red.py b/app/lib/red.py
index 43c02faf1d524b8b363f3be2c208604a3f8daaa8..2a556155c5c276ab349bb58fc3e3512eeadc7790 100644
--- a/app/lib/red.py
+++ b/app/lib/red.py
@@ -1,32 +1,4 @@
-"""A library for interacting with redis."""
-from redis import StrictRedis
-from parse import parse
-
-
-class RedisWrapper(object):
-    """A wrapper for Redis."""
-    def get_database(self, database):
-        """Gets an actual database."""
-        return StrictRedis(host=self.host, port=self.port, db=database)
-
-    def init_app(self, app):
-        """Stores information about the redis database from the URI."""
-        uri = app.config.get('REDIS_URI')
-        self.host, self.port = parse('redis://{}:{}/', uri)
-
-        # key/tokens for applications that this service serves.
-        self.server_apps = self.get_database(0)
-        # key/tokens for applications that this service consumes.
-        self.client_apps = self.get_database(1)
-        # key/tokens for users
-        self.users = self.get_database(2)
-
-    def flushdb(self):
-        """Flushes each database."""
-        self.server_apps.flushdb()
-        self.client_apps.flushdb()
-        self.users.flushdb()
-
+from bpvalve.flask.lib.red import RedisWrapper
 
 redis = RedisWrapper()
 
diff --git a/app/models/base.py b/app/models/base.py
index e304c904fa6fad7ec21fb11bc515609e208a900f..c4470e2a51777600a1fd8b3593d8f47910fb40fd 100644
--- a/app/models/base.py
+++ b/app/models/base.py
@@ -59,6 +59,11 @@ class Model(BaseModel):
     id = db.Column(db.Integer, primary_key=True)
 
 
+class User:
+    user_created = db.Column(db.String(64))
+    user_modified = db.Column(db.String(64))
+
+
 class Tracked(object):
     """A mixin to include tracking datetime fields."""
     created = db.Column(columns.Arrow, default=func.now())
diff --git a/app/models/building_sensor.py b/app/models/building_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..0436ce5cd19f014e26b3ddd2dd9fafe33ab0e0e5
--- /dev/null
+++ b/app/models/building_sensor.py
@@ -0,0 +1,22 @@
+from .base import Model, Tracked, User
+from ..lib.database import db
+
+from sqlalchemy.ext.declarative import declared_attr
+
+class BuildingSensor(Model, User, Tracked, db.Model):
+
+    @declared_attr
+    def __tablename__(cls):
+        return "building_sensor"
+
+    __table_args__ = {"schema": "sensor"}
+
+    building_id = db.Column(db.Integer)
+    date_of_install = db.Column(db.Date)
+    sensor_type = db.Column(db.Integer)
+    heating_system_type = db.Column(db.Integer)
+    gateway_serial = db.Column(db.Integer)
+    gateway_id = db.Column(db.Integer)
+    installer_name = db.Column(db.Unicode(50))
+    placement_type = db.Column(db.Integer)
+    notes = db.Column(db.Unicode(500))
diff --git a/app/models/building_sensor_apartment_node.py b/app/models/building_sensor_apartment_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..9d1ae5fb21b75cda01835e99b54eaf005e78b0ef
--- /dev/null
+++ b/app/models/building_sensor_apartment_node.py
@@ -0,0 +1,25 @@
+from .base import Model, Tracked, User
+from ..lib.database import db
+
+from sqlalchemy.ext.declarative import declared_attr
+
+class BuildingSensorApartmentNode(Model, Tracked, User, db.Model):
+
+    @declared_attr
+    def __tablename__(cls):
+        return "building_sensor_apartment_node"
+
+    __table_args__ = {"schema": "sensor"}
+
+    parent_id = db.Column(db.Integer)
+    node_id = db.Column(db.Integer)
+    node_location = db.Column(db.Unicode(100))
+    apartment_number = db.Column(db.Unicode(10))
+    apartment_floor = db.Column(db.Unicode(10))
+    number_of_bedrooms = db.Column(db.Unicode(10))
+    tenant_name = db.Column(db.Unicode(50))
+    tenant_contact = db.Column(db.Unicode(100))
+    apartment_orientation = db.Column(db.Integer)
+    node_wall_type = db.Column(db.Unicode(50))
+    tenant_heating_issue = db.Column(db.Unicode(50))
+    notes = db.Column(db.Unicode(500))
diff --git a/app/models/building_sensor_boiler_node.py b/app/models/building_sensor_boiler_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..bfb656447322b743e3661a0e9093c344dd00d2c0
--- /dev/null
+++ b/app/models/building_sensor_boiler_node.py
@@ -0,0 +1,21 @@
+from .base import Model, Tracked, User
+from ..lib.database import db
+
+from sqlalchemy.ext.declarative import declared_attr
+
+class BuildingSensorBoilerNode(Model, User, Tracked, db.Model):
+
+    @declared_attr
+    def __tablename__(cls):
+        return "building_sensor_boiler_node"
+
+    __table_args__ = {"schema": "sensor"}
+
+    parent_id = db.Column(db.Integer)
+    node_id = db.Column(db.Unicode(30))
+    node_location = db.Column(db.Unicode(100))
+    temperature_probe_1 = db.Column(db.Integer)
+    temperature_probe_2 = db.Column(db.Integer)
+    temperature_probe_3 = db.Column(db.Integer)
+    temperature_probe_4 = db.Column(db.Integer)
+    notes = db.Column(db.Unicode(500))
diff --git a/app/models/building_sensor_repeater_node.py b/app/models/building_sensor_repeater_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..05a8b98f0c130900586dcd697f69765a48861a2f
--- /dev/null
+++ b/app/models/building_sensor_repeater_node.py
@@ -0,0 +1,18 @@
+from .base import Model, Tracked, User
+from ..lib.database import db
+
+from sqlalchemy.ext.declarative import declared_attr
+
+class BuildingSensorRepeaterNode(Model, User, Tracked, db.Model):
+
+    @declared_attr
+    def __tablename__(cls):
+        return "building_sensor_repeater_node"
+
+    __table_args__ = {"schema": "sensor"}
+
+    parent_id = db.Column(db.Integer)
+    node_id = db.Column(db.Unicode(30))
+    node_location = db.Column(db.Unicode(100))
+    apartment_floor = db.Column(db.Unicode(100))
+    notes = db.Column(db.Unicode(500))
diff --git a/app/models/sensor_image.py b/app/models/sensor_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd59b1c1ed74f25f283b73d9b7de46b29a22f76b
--- /dev/null
+++ b/app/models/sensor_image.py
@@ -0,0 +1,17 @@
+from .base import Model, Tracked, User
+from ..lib.database import db
+
+from sqlalchemy.ext.declarative import declared_attr
+
+class SensorImage(Model, User, Tracked, db.Model):
+
+    @declared_attr
+    def __tablename__(cls):
+        return "sensor_image"
+
+    __table_args__ = {"schema": "sensor"}
+
+    entity_id = db.Column(db.Integer)
+    entity_type = db.Column(db.Integer)
+    image_type = db.Column(db.Integer)
+    box_id = db.Column(db.Integer)
diff --git a/app/views/__init__.py b/app/views/__init__.py
index 1dcf967d1e5ec2c509c5a7e9c550092aa1c73b23..6e99f084df064be27eae58324524360b4ce92bde 100644
--- a/app/views/__init__.py
+++ b/app/views/__init__.py
@@ -1,10 +1,21 @@
 """Flask-classy views for the flask application."""
-
+from . import (
+    building_sensor,
+    building_sensor_boiler_node,
+    building_sensor_apartment_node,
+    building_sensor_repeater_node,
+    sensor_image,
+)
 
 def register(app):
+
     """Register each view to the application.
-    
+
         This can be used as a comprehensive list of all views that are present
         in the application.
     """
-    pass
+    building_sensor.BuildingSensorView.register(app)
+    building_sensor_boiler_node.BuildingSensorBoilerNodeView.register(app)
+    building_sensor_apartment_node.BuildingSensorApartmentNodeView.register(app)
+    building_sensor_repeater_node.BuildingSensorRepeaterNodeView.register(app)
+    sensor_image.SensorImageView.register(app)
diff --git a/app/views/base.py b/app/views/base.py
index 1a175c57e9aaae6e9b01a3da64eeecfb763279b4..4700da8cccec2b0ca3e7b047f29277ac4361303d 100644
--- a/app/views/base.py
+++ b/app/views/base.py
@@ -1,71 +1,8 @@
-import json
-from werkzeug.exceptions import NotFound
-from flask import jsonify, request, current_app
-from flask.ext.classy import FlaskView
-from app.lib.database import db
-from app.lib.red import redis
+from bpvalve.flask.views import UnprotectedRestView
 from app.permissions.auth import standard_login_need
 
 
-class View(FlaskView):
-    """A base view to provide convenience methods to subclasses."""
-    def request_json(self):
-        """Return json parsed from the request."""
-        return json.loads(request.data.decode('utf-8'))
-
-    def json(self, obj, status=200):
-        """A wrapper for Flask's jsonify()."""
-        response = jsonify(data=obj)
-        return response, status
-
-    def parse(self, model):
-        """Parse the model into a dictionary."""
-        return model.get_dictionary()
-
-
-class UnprotectedRestView(View):
-    """A view wrapper for RESTful controllers that does not offer API
-        protection.
-
-        Views should remain agnostic to the database (with the exception of
-        permissions).  In general, the view is responsible for parsing the
-        request, checking permissions, calling the controller, and parsing that
-        return into a json output.
-    """
-    def get_controller(self):
-        """Return a controller instance to use for database interactions."""
-        pass
-
-    def index(self):
-        """/ GET - Retrieve a list of resources."""
-        return self.json([
-            self.parse(m) for m in self.get_controller().index(request.args)
-        ])
-
-    def get(self, id_):
-        """/{id} GET - Retrieve a resource by id."""
-        return self.json(self.parse(
-            self.get_controller().get(id_, request.args)
-        ))
-
-    def post(self):
-        """/ POST - Post a new resource."""
-        return self.json(self.parse(
-            self.get_controller().post(self.request_json(), request.args)
-        ), 201)
-
-    def put(self, id_):
-        """/{id} PUT - Modify a resource by id."""
-        return self.json(self.parse(
-            self.get_controller().put(id_, self.request_json(), request.args)
-        ))
-
-    def delete(self, id_):
-        """/{id} DELETE - Delete a resource by id."""
-        return self.json(self.get_controller().delete(id_, request.args), 204)
-
-
 class RestView(UnprotectedRestView):
-    """A view wrapper for RESTful controllers that _does_ offer API protection.
-    """
+    """A view wrapper for RESTful controllers that _does_ offer API protection."""
+
     decorators = (standard_login_need,)
diff --git a/app/views/building_sensor.py b/app/views/building_sensor.py
new file mode 100644
index 0000000000000000000000000000000000000000..d8c63d5ad9cfd53555e03530c6ef7072e10f8700
--- /dev/null
+++ b/app/views/building_sensor.py
@@ -0,0 +1,12 @@
+"""Views for working with accounts."""
+from .base import RestView
+from ..controllers.building_sensor import BuildingSensorController
+
+from flask import request
+
+class BuildingSensorView(RestView):
+    """The sensor view."""
+
+    def get_controller(self):
+        """Return an instance of the sensor controller."""
+        return BuildingSensorController()
diff --git a/app/views/building_sensor_apartment_node.py b/app/views/building_sensor_apartment_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..3f4a6c513fe0da548d3bb00aa1b62e5d0c4cd48d
--- /dev/null
+++ b/app/views/building_sensor_apartment_node.py
@@ -0,0 +1,12 @@
+"""Views for working with accounts."""
+from .base import RestView
+from ..controllers.building_sensor_apartment_node import BuildingSensorApartmentNodeController
+
+from flask import request
+
+class BuildingSensorApartmentNodeView(RestView):
+    """The apartment node view."""
+
+    def get_controller(self):
+        """Return an instance of the apartment node controller."""
+        return BuildingSensorApartmentNodeController()
diff --git a/app/views/building_sensor_boiler_node.py b/app/views/building_sensor_boiler_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..df8c7a0e0f29d25583871e1c23032c89b72dd7e8
--- /dev/null
+++ b/app/views/building_sensor_boiler_node.py
@@ -0,0 +1,12 @@
+"""Views for working with accounts."""
+from .base import RestView
+from ..controllers.building_sensor_boiler_node import BuildingSensorBoilerNodeController
+
+from flask import request
+
+class BuildingSensorBoilerNodeView(RestView):
+    """The boiler node view."""
+
+    def get_controller(self):
+        """Return an instance of the boiler node controller."""
+        return BuildingSensorBoilerNodeController()
diff --git a/app/views/building_sensor_repeater_node.py b/app/views/building_sensor_repeater_node.py
new file mode 100644
index 0000000000000000000000000000000000000000..e0588f62cebd30c9d7742760ce9eea72925c4bd7
--- /dev/null
+++ b/app/views/building_sensor_repeater_node.py
@@ -0,0 +1,12 @@
+"""Views for working with accounts."""
+from .base import RestView
+from ..controllers.building_sensor_repeater_node import BuildingSensorRepeaterNodeController
+
+from flask import request
+
+class BuildingSensorRepeaterNodeView(RestView):
+    """The repeater node view."""
+
+    def get_controller(self):
+        """Return an instance of the repeater node controller."""
+        return BuildingSensorRepeaterNodeController()
diff --git a/app/views/sensor_image.py b/app/views/sensor_image.py
new file mode 100644
index 0000000000000000000000000000000000000000..6fb2fb94b2b338439d55c814b222ecb5c61db2ff
--- /dev/null
+++ b/app/views/sensor_image.py
@@ -0,0 +1,20 @@
+"""Views for working with sensor images."""
+from .base import RestView
+from ..controllers.sensor_image import SensorImageController
+
+from flask import request
+from werkzeug.exceptions import MethodNotAllowed
+
+class SensorImageView(RestView):
+    """The sensor image view."""
+
+    def get_controller(self):
+        """Return an instance of the sensor image controller."""
+        return SensorImageController()
+
+    def delete(self, id_):
+        raise MethodNotAllowed()
+
+    def put(self, id_):
+        raise MethodNotAllowed()
+
diff --git a/requirements-dev.txt b/requirements-dev.txt
index 5660f022283738e06640ee95df95506320277c59..2748f38cc5c9e3ba6e533abbf10af2f473d9aca9 100644
--- a/requirements-dev.txt
+++ b/requirements-dev.txt
@@ -1,6 +1,9 @@
 -r requirements.txt
 Flask-Testing==0.4.2
 nose==1.3.7
+pycodestyle>=2.3.1
+pydocstyle>=1.1.1
 pytest==2.9.1
 pylint>=1.6.5
 pylint-flask>=0.5
+yapf>=0.16.1
diff --git a/requirements.txt b/requirements.txt
index 0a28abde5facb4b6c5a38252201bc95dc9360d63..8fce59b1edca82b89e9bf0de9d98a9c752bd79d2 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,7 @@
 arrow==0.7.0
 blessed==1.9.5
 botocore==1.3.28
+git+ssh://git@github.com/Blocp/bpvalve.git@v1.1.2
 cement==2.4.0
 colorama==0.3.3
 docker-py==1.1.0
diff --git a/run.py b/run.py
index 1ab56a6f32fd5934c77c5f3a458d1fc6d093b81e..d3a3765f53d40eab21131b9437d5bdbed55f4145 100644
--- a/run.py
+++ b/run.py
@@ -4,4 +4,4 @@ from app.lib.database import db
 
 app = create_app('config/local.py')
 if __name__ == '__main__':
-    app.run(host='0.0.0.0', port=5300)
+    app.run(host='0.0.0.0', port=5308)
diff --git a/setup.cfg b/setup.cfg
new file mode 100644
index 0000000000000000000000000000000000000000..64a0dfb03c1ac2943c7e7bc75475d5d685df4f9f
--- /dev/null
+++ b/setup.cfg
@@ -0,0 +1,9 @@
+[pycodestyle]
+max-line-length=100
+
+[isort]
+line_length=100
+
+[yapf]
+based_on_style=pep8
+spaces_before_comment=1