Merge pull request #1639 from alphagov/create-new-organisation-model

Create new organisation model

app/__init__.py

@@ -107,6 +107,7 @@ def register_blueprint(application):
     from app.authentication.auth import requires_admin_auth, requires_auth, requires_no_auth
     from app.letters.rest import letter_job
     from app.billing.rest import billing_blueprint
+    from app.organisation.rest import organisation_blueprint
 
     service_blueprint.before_request(requires_admin_auth)
     application.register_blueprint(service_blueprint, url_prefix='/service')
@@ -177,6 +178,9 @@ def register_blueprint(application):
     service_callback_blueprint.before_request(requires_admin_auth)
     application.register_blueprint(service_callback_blueprint)
 
+    organisation_blueprint.before_request(requires_admin_auth)
+    application.register_blueprint(organisation_blueprint, url_prefix='/organisations')
+
 
 def register_v2_blueprints(application):
     from app.v2.inbound_sms.get_inbound_sms import v2_inbound_sms_blueprint as get_inbound_sms

app/dao/organisation_dao.py

@@ -0,0 +1,25 @@
+from app import db
+from app.dao.dao_utils import transactional
+from app.models import Organisation
+
+
+def dao_get_organisations():
+    return Organisation.query.order_by(
+        Organisation.active.desc(), Organisation.name.asc()
+    ).all()
+
+
+def dao_get_organisation_by_id(organisation_id):
+    return Organisation.query.filter_by(id=organisation_id).one()
+
+
+@transactional
+def dao_create_organisation(organisation):
+    db.session.add(organisation)
+
+
+@transactional
+def dao_update_organisation(organisation_id, **kwargs):
+    return Organisation.query.filter_by(id=organisation_id).update(
+        kwargs
+    )

app/models.py

@@ -303,6 +303,24 @@ class Service(db.Model, Versioned):
         return permission in [p.permission for p in self.permissions]
 
 
+class Organisation(db.Model):
+    __tablename__ = "organisation"
+    id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=False)
+    name = db.Column(db.String(255), nullable=False, unique=True, index=True)
+    active = db.Column(db.Boolean, nullable=False, default=True)
+    created_at = db.Column(db.DateTime, nullable=False, default=datetime.datetime.utcnow)
+    updated_at = db.Column(db.DateTime, nullable=True, onupdate=datetime.datetime.utcnow)
+
+    def serialize(self):
+        serialized = {
+            "id": str(self.id),
+            "name": self.name,
+            "active": self.active,
+        }
+
+        return serialized
+
+
 class AnnualBilling(db.Model):
     __tablename__ = "annual_billing"
     id = db.Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4, unique=False)

app/organisation/organisation_schema.py

@@ -0,0 +1,21 @@
+post_create_organisation_schema = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "POST organisation schema",
+    "type": "object",
+    "properties": {
+        "name": {"type": "string"},
+        "active": {"type": ["boolean", "null"]}
+    },
+    "required": ["name"]
+}
+
+post_update_organisation_schema = {
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "description": "POST organisation schema",
+    "type": "object",
+    "properties": {
+        "name": {"type": ["string", "null"]},
+        "active": {"type": ["boolean", "null"]}
+    },
+    "required": []
+}

app/organisation/rest.py

@@ -0,0 +1,57 @@
+from flask import Blueprint, jsonify, request
+
+from app.dao.organisation_dao import (
+    dao_create_organisation,
+    dao_get_organisations,
+    dao_get_organisation_by_id,
+    dao_update_organisation,
+)
+from app.errors import register_errors, InvalidRequest
+from app.models import Organisation
+from app.organisation.organisation_schema import (
+    post_create_organisation_schema,
+    post_update_organisation_schema,
+)
+from app.schema_validation import validate
+
+organisation_blueprint = Blueprint('organisation', __name__)
+register_errors(organisation_blueprint)
+
+
+@organisation_blueprint.route('', methods=['GET'])
+def get_organisations():
+    organisations = [
+        org.serialize() for org in dao_get_organisations()
+    ]
+
+    return jsonify(organisations)
+
+
+@organisation_blueprint.route('/<uuid:organisation_id>', methods=['GET'])
+def get_organisation_by_id(organisation_id):
+    organisation = dao_get_organisation_by_id(organisation_id)
+    return jsonify(organisation.serialize())
+
+
+@organisation_blueprint.route('', methods=['POST'])
+def create_organisation():
+    data = request.get_json()
+
+    validate(data, post_create_organisation_schema)
+
+    organisation = Organisation(**data)
+    dao_create_organisation(organisation)
+
+    return jsonify(organisation.serialize()), 201
+
+
+@organisation_blueprint.route('/<uuid:organisation_id>', methods=['POST'])
+def update_organisation(organisation_id):
+    data = request.get_json()
+    validate(data, post_update_organisation_schema)
+    result = dao_update_organisation(organisation_id, **data)
+
+    if result:
+        return '', 204
+    else:
+        raise InvalidRequest("Organisation not found", 404)

migrations/versions/0163_add_new_org_model.py

@@ -0,0 +1,34 @@
+"""
+
+Revision ID: 0163_add_new_org_model
+Revises: 0162_remove_org
+Create Date: 2018-02-07 14:03:00.804849
+
+"""
+from alembic import op
+import sqlalchemy as sa
+from sqlalchemy.dialects import postgresql
+
+revision = '0163_add_new_org_model'
+down_revision = '0162_remove_org'
+
+
+def upgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('organisation',
+    sa.Column('id', postgresql.UUID(as_uuid=True), nullable=False),
+    sa.Column('name', sa.String(length=255), nullable=False),
+    sa.Column('active', sa.Boolean(), nullable=False),
+    sa.Column('created_at', sa.DateTime(), nullable=False),
+    sa.Column('updated_at', sa.DateTime(), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    op.create_index(op.f('ix_organisation_name'), 'organisation', ['name'], unique=True)
+    # ### end Alembic commands ###
+
+
+def downgrade():
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_index(op.f('ix_organisation_name'), table_name='organisation')
+    op.drop_table('organisation')
+    # ### end Alembic commands ###

tests/app/dao/test_organisation_dao.py

@@ -0,0 +1,53 @@
+from app.dao.organisation_dao import (
+    dao_get_organisations,
+    dao_get_organisation_by_id,
+    dao_update_organisation,
+)
+from app.models import Organisation
+
+from tests.app.db import create_organisation
+
+
+def test_get_organisations_gets_all_organisations_alphabetically_with_active_organisations_first(
+    notify_db,
+    notify_db_session
+):
+    m_active_org = create_organisation(name='m_active_organisation')
+    z_inactive_org = create_organisation(name='z_inactive_organisation', active=False)
+    a_inactive_org = create_organisation(name='a_inactive_organisation', active=False)
+    z_active_org = create_organisation(name='z_active_organisation')
+    a_active_org = create_organisation(name='a_active_organisation')
+
+    organisations = dao_get_organisations()
+
+    assert len(organisations) == 5
+    assert organisations[0] == a_active_org
+    assert organisations[1] == m_active_org
+    assert organisations[2] == z_active_org
+    assert organisations[3] == a_inactive_org
+    assert organisations[4] == z_inactive_org
+
+
+def test_get_organisation_by_id_gets_correct_organisation(notify_db, notify_db_session):
+    organisation = create_organisation()
+
+    organisation_from_db = dao_get_organisation_by_id(organisation.id)
+
+    assert organisation_from_db == organisation
+
+
+def test_update_organisation(notify_db, notify_db_session):
+    updated_name = 'new name'
+    create_organisation()
+
+    organisation = Organisation.query.all()
+
+    assert len(organisation) == 1
+    assert organisation[0].name != updated_name
+
+    dao_update_organisation(organisation[0].id, **{'name': updated_name})
+
+    organisation = Organisation.query.all()
+
+    assert len(organisation) == 1
+    assert organisation[0].name == updated_name

tests/app/db.py

@@ -14,6 +14,7 @@ from app.models import (
     MonthlyBilling,
     Notification,
     EmailBranding,
+    Organisation,
     Rate,
     Service,
     ServiceEmailReplyTo,
@@ -41,6 +42,7 @@ from app.dao.services_dao import dao_create_service
 from app.dao.service_permissions_dao import dao_add_service_permission
 from app.dao.inbound_sms_dao import dao_create_inbound_sms
 from app.dao.email_branding_dao import dao_create_email_branding
+from app.dao.organisation_dao import dao_create_organisation
 
 
 def create_user(mobile_number="+447700900986", email="notify@digital.cabinet-office.gov.uk", state='active'):
@@ -479,3 +481,14 @@ def create_letter_rate(
     db.session.commit()
 
     return rate
+
+
+def create_organisation(name='test_org_1', active=True):
+    data = {
+        'name': name,
+        'active': active
+    }
+    organisation = Organisation(**data)
+    dao_create_organisation(organisation)
+
+    return organisation

tests/app/organisation/test_rest.py

@@ -0,0 +1,105 @@
+from app.models import Organisation
+from tests.app.db import create_organisation
+
+
+def test_get_all_organisations(admin_request, notify_db_session):
+    create_organisation(name='inactive org', active=False)
+    create_organisation(name='active org')
+
+    response = admin_request.get(
+        'organisation.get_organisations',
+        _expected_status=200
+    )
+
+    assert len(response) == 2
+    assert response[0]['name'] == 'active org'
+    assert response[0]['active'] is True
+    assert response[1]['name'] == 'inactive org'
+    assert response[1]['active'] is False
+
+
+def test_get_organisation_by_id(admin_request, notify_db_session):
+    org = create_organisation()
+
+    response = admin_request.get(
+        'organisation.get_organisation_by_id',
+        _expected_status=200,
+        organisation_id=org.id
+    )
+
+    assert set(response.keys()) == {'id', 'name', 'active'}
+    assert response['id'] == str(org.id)
+    assert response['name'] == 'test_org_1'
+    assert response['active'] is True
+
+
+def test_post_create_organisation(admin_request, notify_db_session):
+    data = {
+        'name': 'test organisation',
+        'active': True
+    }
+
+    response = admin_request.post(
+        'organisation.create_organisation',
+        _data=data,
+        _expected_status=201
+    )
+
+    organisation = Organisation.query.all()
+
+    assert data['name'] == response['name']
+    assert data['active'] == response['active']
+    assert len(organisation) == 1
+
+
+def test_post_create_organisation_with_missing_name_gives_validation_error(admin_request, notify_db_session):
+    data = {
+        'active': False
+    }
+
+    response = admin_request.post(
+        'organisation.create_organisation',
+        _data=data,
+        _expected_status=400
+    )
+
+    assert len(response['errors']) == 1
+    assert response['errors'][0]['error'] == 'ValidationError'
+    assert response['errors'][0]['message'] == 'name is a required property'
+
+
+def test_post_update_organisation_updates_fields(admin_request, notify_db_session):
+    org = create_organisation()
+    data = {
+        'name': 'new organisation name',
+        'active': False
+    }
+
+    admin_request.post(
+        'organisation.update_organisation',
+        _data=data,
+        organisation_id=org.id,
+        _expected_status=204
+    )
+
+    organisation = Organisation.query.all()
+
+    assert len(organisation) == 1
+    assert organisation[0].id == org.id
+    assert organisation[0].name == data['name']
+    assert organisation[0].active == data['active']
+
+
+def test_post_update_organisation_gives_404_status_if_org_does_not_exist(admin_request, notify_db_session):
+    data = {'name': 'new organisation name'}
+
+    admin_request.post(
+        'organisation.update_organisation',
+        _data=data,
+        organisation_id='31d42ce6-3dac-45a7-95cb-94423d5ca03c',
+        _expected_status=404
+    )
+
+    organisation = Organisation.query.all()
+
+    assert not organisation