README.md

[![Build Status](https://travis-ci.org/alphagov/notifications-admin.svg)](https://travis-ci.org/alphagov/notifications-admin)
[![Requirements Status](https://requires.io/github/alphagov/notifications-admin/requirements.svg?branch=master)](https://requires.io/github/alphagov/notifications-admin/requirements/?branch=master)


# notifications-admin

Application to handle the admin functions of the notifications application.

## Features of this application

 - Register users
 - Register services
 - Download CSV for an email or SMS batch
 - Show history of notifications
 - Reports

## First-time setup

You need [Node](http://nodejs.org/) which will also get you [NPM](npmjs.org),
Node's package management tool.
```shell
    brew install node
```

n is a tool for managing different versions of node. The following installs n
and uses the latest version of node.
```shell
    npm install -g n
    n latest
    npm rebuild node-sass
```

The frontend dependencies are managed using NPM and Bower. To install or update
*all the things*, run
```shell
    npm install
    npm run build
```

The app runs within a virtual environment. To [install virtualenv](https://virtualenv.readthedocs.org/en/latest/installation.html), run
```shell
    [sudo] pip install virtualenv
```

To make a virtualenv for this app, run
```shell
    mkvirtualenv -p /usr/local/bin/python3 notifications-admin
    pip install -r requirements.txt
    ./scripts/bootstrap.sh
```

## Building the frontend

If you want the front end assets to re-compile on changes, leave this running
in a separate terminal from the app
```shell
    npm run watch
```

## Running the application

```shell
    workon notifications-admin
    ./scripts/run_app.sh
```

Then visit [localhost:6012](localhost:6012)

## Domain model

All the domain models are defined in the
[models.py](https://github.com/alphagov/notifications-admin/blob/master/app/models.py)
file.
Add badges for requirements and code coverage 2016-01-12 09:38:55 +00:00			`[![Build Status](https://travis-ci.org/alphagov/notifications-admin.svg)](https://travis-ci.org/alphagov/notifications-admin)`
			`[![Requirements Status](https://requires.io/github/alphagov/notifications-admin/requirements.svg?branch=master)](https://requires.io/github/alphagov/notifications-admin/requirements/?branch=master)`
Fix code style 2015-11-23 14:55:37 +00:00
Update README.md 2015-11-18 16:41:49 +00:00
Change name of app 2015-11-20 10:31:28 +00:00			`# notifications-admin`
Update README.md 2015-11-18 16:32:15 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`Application to handle the admin functions of the notifications application.`
Update README.md 2015-11-23 14:37:29 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`## Features of this application`
Remove sass dir Update ReadMe with Getting Started directions 2015-11-23 14:31:14 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`- Register users`
			`- Register services`
			`- Download CSV for an email or SMS batch`
			`- Show history of notifications`
			`- Reports`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`## First-time setup`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00
			`You need [Node](http://nodejs.org/) which will also get you [NPM](npmjs.org),`
			`Node's package management tool.`
			```shell
			`brew install node`
			```

Update README No longer need to do init the submodules when first using the app. 2016-01-14 16:26:56 +00:00			`n is a tool for managing different versions of node. The following installs n`
			`and uses the latest version of node.`
			```shell
Update README.md Added instructions to install n for node version management 2016-01-06 11:14:04 +00:00			`npm install -g n`
			`n latest`
			`npm rebuild node-sass`
Update README No longer need to do init the submodules when first using the app. 2016-01-14 16:26:56 +00:00			```
Fix flakiness with Gulp + Travis Gulp was failing silently on Travis. I tracked this down to the task that builds a custom, slimmed-down version of jQuery from source. To fix this I’ve removed the task and replaced it with just `src`ing the minified version of jQuery from `node_modules`. Cons: - A few more kb of JS Pros: - Less random, afternoon-chewing complexity 2016-01-12 13:37:50 +00:00
Update README No longer need to do init the submodules when first using the app. 2016-01-14 16:26:56 +00:00			`The frontend dependencies are managed using NPM and Bower. To install or update`
			`all the things, run`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00			```shell
			`npm install`
Fix flakiness with Gulp + Travis Gulp was failing silently on Travis. I tracked this down to the task that builds a custom, slimmed-down version of jQuery from source. To fix this I’ve removed the task and replaced it with just `src`ing the minified version of jQuery from `node_modules`. Cons: - A few more kb of JS Pros: - Less random, afternoon-chewing complexity 2016-01-12 13:37:50 +00:00			`npm run build`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00			```

Tidy up README 2016-02-03 15:18:57 +00:00			`The app runs within a virtual environment. To [install virtualenv](https://virtualenv.readthedocs.org/en/latest/installation.html), run`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00			```shell
Tidy up README 2016-02-03 15:18:57 +00:00			`[sudo] pip install virtualenv`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00			```
Remove sass dir Update ReadMe with Getting Started directions 2015-11-23 14:31:14 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`To make a virtualenv for this app, run`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00			```shell
Tidy up README 2016-02-03 15:18:57 +00:00			`mkvirtualenv -p /usr/local/bin/python3 notifications-admin`
108536234: created users and roles data and domain model. You will need to run the /scripts/bootstrap.sh to create the database for test and the app. 2015-11-25 15:29:12 +00:00			`pip install -r requirements.txt`
Tidy up README 2016-02-03 15:18:57 +00:00			`./scripts/bootstrap.sh`
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00			```

Tidy up README 2016-02-03 15:18:57 +00:00			`## Building the frontend`
Remove sass dir Update ReadMe with Getting Started directions 2015-11-23 14:31:14 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`If you want the front end assets to re-compile on changes, leave this running`
			`in a separate terminal from the app`
			```shell
			`npm run watch`
			```
Update README.md 2015-12-10 16:47:29 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`## Running the application`

			```shell
			`workon notifications-admin`
			`./scripts/run_app.sh`
			```
108536234: created users and roles data and domain model. You will need to run the /scripts/bootstrap.sh to create the database for test and the app. 2015-11-25 15:29:12 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`Then visit [localhost:6012](localhost:6012)`
108536234: created users and roles data and domain model. You will need to run the /scripts/bootstrap.sh to create the database for test and the app. 2015-11-25 15:29:12 +00:00
Tidy up README 2016-02-03 15:18:57 +00:00			`## Domain model`
Update README.md 2015-11-23 14:39:31 +00:00
Use a Node-based tools for handling assets …or how to move a bunch of things from a bunch of different places into `app/static`. There are three main reasons not to use Flask Assets: - It had some strange behaviour like only - It was based on Ruby SASS, which is slower to get new features than libsass, and meant depending on Ruby, and having the SASS Gem globally installed—so you’re already out of being a ‘pure’ Python app - Martyn and I have experience of doing it this way on Marketplace, and we’ve ironed out the initial rough patches The specific technologies this introduces, all of which are Node-based: - Gulp – like a Makefile written in Javascript - NPM – package management, used for managing Gulp and its related dependencies - Bower – also package management, and the only way I can think to have GOV.UK template as a proper dependency …speaking of which, GOV.UK template is now a dependency. This means it can’t be modified at all (eg to add a global `#content` wrapper), so every page now inherits from a template that has this wrapper. But it also means that we have a clean upgrade path when the template is modified. Everything else (toolkit, elements) I’ve kept as submodules but moved them to a more logical place (`app/assets` not `app/assets/stylesheets`, because they contain more than just SASS/CSS). 2015-12-15 08:20:25 +00:00			`All the domain models are defined in the`
			`[models.py](https://github.com/alphagov/notifications-admin/blob/master/app/models.py)`
			`file.`