Merge pull request #1054 from digitalocean/develop

Release v1.9.5

CONTRIBUTING.md

@@ -45,10 +45,6 @@ sure to include:
     * Any error messages generated
     * Screenshots (if applicable)
 
-* Please avoid prepending any sort of tag (e.g. "[Bug]") to the issue title.
-The issue will be reviewed by a moderator after submission and the appropriate
-labels will be applied.
-
 * Keep in mind that we prioritize bugs based on their severity and how
 much work is required to resolve them. It may take some time for someone
 to address your issue.
@@ -95,10 +91,6 @@ following:
     * Any third-party libraries or other resources which would be
       involved
 
-* Please avoid prepending any sort of tag (e.g. "[Feature]") to the issue title.
-The issue will be reviewed by a moderator after submission and the appropriate
-labels will be applied.
-
 ## Submitting Pull Requests
 
 * Be sure to open an issue before starting work on a pull request, and

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:2.7-wheezy
+
+WORKDIR /opt/netbox
+
+ARG BRANCH=master
+ARG URL=https://github.com/digitalocean/netbox.git
+RUN git clone --depth 1 $URL -b $BRANCH .  && \
+    apt-get update -qq && apt-get install -y libldap2-dev libsasl2-dev libssl-dev graphviz && \
+	pip install gunicorn==17.5 && \
+	pip install django-auth-ldap && \
+    pip install -r requirements.txt
+
+ADD docker/docker-entrypoint.sh /docker-entrypoint.sh
+ADD netbox/netbox/configuration.docker.py /opt/netbox/netbox/netbox/configuration.py
+
+ENTRYPOINT [ "/docker-entrypoint.sh" ]
+
+ADD docker/gunicorn_config.py /opt/netbox/
+ADD docker/nginx.conf /etc/netbox-nginx/
+VOLUME ["/etc/netbox-nginx/"]

README.md

@@ -10,9 +10,7 @@ Questions? Comments? Please subscribe to [the netbox-discuss mailing list](https
 
 ### Build Status
 
-NetBox is built against both Python 2.7 and 3.5.  Python 3.5 is recommended.
+|             | python 2.7 |
-
-|             | status |
 |-------------|------------|
 | **master** | [![Build Status](https://travis-ci.org/digitalocean/netbox.svg?branch=master)](https://travis-ci.org/digitalocean/netbox) |
 | **develop** | [![Build Status](https://travis-ci.org/digitalocean/netbox.svg?branch=develop)](https://travis-ci.org/digitalocean/netbox) |
@@ -31,6 +29,5 @@ Please see [the documentation](http://netbox.readthedocs.io/en/stable/) for inst
 
 ## Alternative Installations
 
-* [Docker container](https://github.com/digitalocean/netbox-docker)
+* [Docker container](http://netbox.readthedocs.io/en/stable/installation/docker/)
 * [Heroku deployment](https://heroku.com/deploy?template=https://github.com/BILDQUADRAT/netbox/tree/heroku) (via [@mraerino](https://github.com/BILDQUADRAT/netbox/tree/heroku))
-* [Vagrant deployment](https://github.com/ryanmerolle/netbox-vagrant)

docker-compose.yml

@@ -0,0 +1,53 @@
+version: '2'
+
+services:
+    postgres:
+        image: postgres:9.6
+        container_name: postgres
+        environment:
+            POSTGRES_USER: netbox
+            POSTGRES_PASSWORD: J5brHrAXFLQSif0K
+            POSTGRES_DB: netbox
+    netbox:
+        build: .
+        image: digitalocean/netbox
+        links:
+        - postgres
+        container_name: netbox
+        depends_on:
+        - postgres
+        environment:
+            SUPERUSER_NAME: admin
+            SUPERUSER_EMAIL: admin@example.com
+            SUPERUSER_PASSWORD: admin
+            ALLOWED_HOSTS: localhost
+            DB_NAME: netbox
+            DB_USER: netbox
+            DB_PASSWORD: J5brHrAXFLQSif0K
+            DB_HOST: postgres
+            SECRET_KEY: r8OwDznj!!dci#P9ghmRfdu1Ysxm0AiPeDCQhKE+N_rClfWNj
+            EMAIL_SERVER: localhost
+            EMAIL_PORT: 25
+            EMAIL_USERNAME: foo
+            EMAIL_PASSWORD: bar
+            EMAIL_TIMEOUT: 10
+            EMAIL_FROM: netbox@bar.com
+            NETBOX_USERNAME: guest
+            NETBOX_PASSWORD: guest
+        volumes:
+        - netbox-static-files:/opt/netbox/netbox/static
+    nginx:
+        image: nginx:1.11.1-alpine
+        links:
+        - netbox
+        container_name: nginx
+        command: nginx -g 'daemon off;' -c /etc/netbox-nginx/nginx.conf
+        depends_on:
+        - netbox
+        ports:
+        - 80:80
+        volumes_from:
+        - netbox
+volumes:
+    netbox-static-files:
+        driver: local

docker/docker-entrypoint.sh

@@ -0,0 +1,22 @@
+#!/bin/bash
+set -e
+
+# run db migrations (retry on error)
+while ! /opt/netbox/netbox/manage.py migrate 2>&1; do
+    sleep 5
+done
+
+# create superuser silently
+if [[ -z ${SUPERUSER_NAME} || -z ${SUPERUSER_EMAIL} || -z ${SUPERUSER_PASSWORD} ]]; then
+        SUPERUSER_NAME='admin'
+        SUPERUSER_EMAIL='admin@example.com'
+        SUPERUSER_PASSWORD='admin'
+        echo "Using defaults: Username: ${SUPERUSER_NAME}, E-Mail: ${SUPERUSER_EMAIL}, Password: ${SUPERUSER_PASSWORD}"
+fi
+echo "from django.contrib.auth.models import User; User.objects.create_superuser('${SUPERUSER_NAME}', '${SUPERUSER_EMAIL}', '${SUPERUSER_PASSWORD}')" | python /opt/netbox/netbox/manage.py shell
+
+# copy static files
+/opt/netbox/netbox/manage.py collectstatic --no-input
+
+# start unicorn
+gunicorn --log-level debug --debug --error-logfile /dev/stderr --log-file /dev/stdout -c /opt/netbox/gunicorn_config.py netbox.wsgi

docker/gunicorn_config.py

@@ -0,0 +1,5 @@
+command = '/usr/bin/gunicorn'
+pythonpath = '/opt/netbox/netbox'
+bind = '0.0.0.0:8001'
+workers = 3
+user = 'root'

docker/nginx.conf

@@ -0,0 +1,35 @@
+worker_processes 1;
+
+events {
+    worker_connections  1024;
+}
+
+http {
+    include       /etc/nginx/mime.types;
+    default_type  application/octet-stream;
+    sendfile        on;
+    tcp_nopush     on;
+    keepalive_timeout  65;
+    gzip  on;
+    server_tokens off;
+
+    server {
+        listen 80;
+
+        server_name localhost;
+
+        access_log off;
+
+        location /static/ {
+            alias /opt/netbox/netbox/static/;
+        }
+
+        location / {
+            proxy_pass http://netbox:8001;
+            proxy_set_header X-Forwarded-Host $server_name;
+            proxy_set_header X-Real-IP $remote_addr;
+            proxy_set_header X-Forwarded-Proto $scheme;
+            add_header P3P 'CP="ALL DSP COR PSAa PSDa OUR NOR ONL UNI COM NAV"';
+        }
+    }
+}

docs/api-integration.md

@@ -0,0 +1,19 @@
+# API Integration
+
+NetBox features a read-only REST API which can be used to integrate it with
+other applications.
+
+In the future, both read and write actions will be available via the API.
+
+## Clients
+
+The easiest way to start integrating your applications with NetBox is to make
+use of an API client.  If you build or discover an API client that is not part
+of this list, please send a pull request!
+
+- **Go**: [github.com/digitalocean/go-netbox](https://github.com/digitalocean/go-netbox)
+
+## Documentation
+
+If you wish to build a new API client or simply explore the NetBox API,
+Swagger documentation can be found at the URL `/api/docs/` on a NetBox server.

docs/api/authentication.md

@@ -1,48 +0,0 @@
-The NetBox API employs token-based authentication. For convenience, cookie authentication can also be used when navigating the browsable API.
-
-# Tokens
-
-A token is a unique identifier that identifies a user to the API. Each user in NetBox may have one or more tokens which he or she can use to authenticate to the API. To create a token, navigate to the API tokens page at `/user/api-tokens/`.
-
-Each token contains a 160-bit key represented as 40 hexadecimal characters. When creating a token, you'll typically leave the key field blank so that a random key will be automatically generated. However, NetBox allows you to specify a key in case you need to restore a previously deleted token to operation.
-
-By default, a token can be used for all operations available via the API. Deselecting the "write enabled" option will restrict API requests made with the token to read operations (e.g. GET) only.
-
-Additionally, a token can be set to expire at a specific time. This can be useful if an external client needs to be granted temporary access to NetBox.
-
-# Authenticating to the API
-
-By default, read operations will be available without authentication. In this case, a token may be included in the request, but is not necessary.
-
-```
-$ curl -H "Accept: application/json; indent=4" http://localhost/api/dcim/sites/
-{
-    "count": 10,
-    "next": null,
-    "previous": null,
-    "results": [...]
-}
-```
-
-However, if the [`LOGIN_REQUIRED`](../configuration/optional-settings/#login_required) configuration setting has been set to `True`, all requests must be authenticated.
-
-```
-$ curl -H "Accept: application/json; indent=4" http://localhost/api/dcim/sites/
-{
-    "detail": "Authentication credentials were not provided."
-}
-```
-
-To authenticate to the API, set the HTTP `Authorization` header to the string `Token ` (note the trailing space) followed by the token key.
-
-```
-$ curl -H "Authorization: Token d2f763479f703d80de0ec15254237bc651f9cdc0" -H "Accept: application/json; indent=4" http://localhost/api/dcim/sites/
-{
-    "count": 10,
-    "next": null,
-    "previous": null,
-    "results": [...]
-}
-```
-
-Additionally, the browsable interface to the API (which can be seen by navigating to the API root `/api/` in a web browser) will attempt to authenticate requests using the same cookie that the normal NetBox front end uses. Thus, if you have logged into NetBox, you will be logged into the browsable API as well.

docs/api/examples.md

@@ -1,138 +0,0 @@
-# API Examples
-
-Supported HTTP methods:
-
-* `GET`: Retrieve an object or list of objects
-* `POST`: Create a new object
-* `PUT`: Update an existing object
-* `DELETE`: Delete an existing object
-
-To authenticate a request, attach your token in an `Authorization` header:
-
-```
-curl -H "Authorization: Token d2f763479f703d80de0ec15254237bc651f9cdc0"
-```
-
-### Retrieving a list of sites
-
-Send a `GET` request to the object list endpoint. The response contains a paginated list of JSON objects.
-
-```
-$ curl -H "Accept: application/json; indent=4" http://localhost/api/dcim/sites/
-{
-    "count": 14,
-    "next": null,
-    "previous": null,
-    "results": [
-        {
-            "id": 6,
-            "name": "Corporate HQ",
-            "slug": "corporate-hq",
-            "region": null,
-            "tenant": null,
-            "facility": "",
-            "asn": null,
-            "physical_address": "742 Evergreen Terrace, Springfield, USA",
-            "shipping_address": "",
-            "contact_name": "",
-            "contact_phone": "",
-            "contact_email": "",
-            "comments": "",
-            "custom_fields": {},
-            "count_prefixes": 108,
-            "count_vlans": 46,
-            "count_racks": 8,
-            "count_devices": 254,
-            "count_circuits": 6
-        },
-        ...
-    ]
-}
-```
-
-### Retrieving a single site by ID
-
-Send a `GET` request to the object detail endpoint. The response contains a single JSON object.
-
-```
-$ curl -H "Accept: application/json; indent=4" http://localhost/api/dcim/sites/6/
-{
-    "id": 6,
-    "name": "Corporate HQ",
-    "slug": "corporate-hq",
-    "region": null,
-    "tenant": null,
-    "facility": "",
-    "asn": null,
-    "physical_address": "742 Evergreen Terrace, Springfield, USA",
-    "shipping_address": "",
-    "contact_name": "",
-    "contact_phone": "",
-    "contact_email": "",
-    "comments": "",
-    "custom_fields": {},
-    "count_prefixes": 108,
-    "count_vlans": 46,
-    "count_racks": 8,
-    "count_devices": 254,
-    "count_circuits": 6
-}
-```
-
-### Creating a new site
-
-Send a `POST` request to the site list endpoint with token authentication and JSON-formatted data. Only mandatory fields are required.
-
-```
-$ curl -X POST -H "Authorization: Token d2f763479f703d80de0ec15254237bc651f9cdc0" -H "Content-Type: application/json" -H "Accept: application/json; indent=4" http://localhost:8000/api/dcim/sites/ --data '{"name": "My New Site", "slug": "my-new-site"}'
-{
-    "id": 16,
-    "name": "My New Site",
-    "slug": "my-new-site",
-    "region": null,
-    "tenant": null,
-    "facility": "",
-    "asn": null,
-    "physical_address": "",
-    "shipping_address": "",
-    "contact_name": "",
-    "contact_phone": "",
-    "contact_email": "",
-    "comments": ""
-}
-```
-
-### Modify an existing site
-
-Make an authenticated `PUT` request to the site detail endpoint. As with a create (POST) request, all mandatory fields must be included.
-
-```
-$ curl -X PUT -H "Authorization: Token d2f763479f703d80de0ec15254237bc651f9cdc0" -H "Content-Type: application/json" -H "Accept: application/json; indent=4" http://localhost:8000/api/dcim/sites/16/ --data '{"name": "Renamed Site", "slug": "renamed-site"}'
-```
-
-### Delete an existing site
-
-Send an authenticated `DELETE` request to the site detail endpoint.
-
-```
-$ curl -v X DELETE -H "Authorization: Token d2f763479f703d80de0ec15254237bc651f9cdc0" -H "Content-Type: application/json" -H "Accept: application/json; indent=4" http://localhost:8000/api/dcim/sites/16/
-* Connected to localhost (127.0.0.1) port 8000 (#0)
-> DELETE /api/dcim/sites/16/ HTTP/1.1
-> User-Agent: curl/7.35.0
-> Host: localhost:8000
-> Authorization: Token d2f763479f703d80de0ec15254237bc651f9cdc0
-> Content-Type: application/json
-> Accept: application/json; indent=4
->
-* HTTP 1.0, assume close after body
-< HTTP/1.0 204 No Content
-< Date: Mon, 20 Mar 2017 16:13:08 GMT
-< Server: WSGIServer/0.1 Python/2.7.6
-< Vary: Accept, Cookie
-< X-Frame-Options: SAMEORIGIN
-< Allow: GET, PUT, PATCH, DELETE, OPTIONS
-<
-* Closing connection 0
-```
-
-The response to a successfull `DELETE` request will have code 204 (No Content); the body of the response will be empty.

docs/api/overview.md

@@ -1,143 +0,0 @@
-NetBox v2.0 and later includes a full-featured REST API that allows its data model to be read and manipulated externally.
-
-# URL Hierarchy
-
-NetBox's entire REST API is housed under the API root, `/api/`. The API's URL structure is divided at the root level by application: circuits, DCIM, extras, IPAM, secrets, and tenancy. Within each application, each model has its own path. For example, the provider and circuit objects are located under the "circuits" application:
-
-* /api/circuits/providers/
-* /api/circuits/circuits/
-
-Likewise, the site, rack, and device objects are located under the "DCIM" application:
-
-* /api/dcim/sites/
-* /api/dcim/racks/
-* /api/dcim/devices/
-
-The full hierarchy of available endpoints can be viewed by navigating to the API root (e.g. /api/) in a web browser.
-
-Each model generally has two URLs associated with it: a list URL and a detail URL. The list URL is used to request a list of multiple objects or to create a new object. The detail URL is used to retrieve, update, or delete an existing object. All objects are referenced by their numeric primary key (ID).
-
-* /api/dcim/devices/ - List devices or create a new device
-* /api/dcim/devices/123/ - Retrieve, update, or delete the device with ID 123
-
-Lists of objects can be filtered using a set of query parameters. For example, to find all interfaces belonging to the device with ID 123:
-
-```
-GET /api/dcim/interfaces/?device_id=123
-```
-
-# Serialization
-
-The NetBox API employs three types of serializers to represent model data:
-
-* Base serializer
-* Nested serializer
-* Writable serializer
-
-The base serializer is used to represent the default view of a model. This includes all database table fields which comprise the model, and may include additional metadata. A base serializer includes relationships to parent objects, but **does not** include child objects. For example, the `VLANSerializer` includes a nested representation its parent VLANGroup (if any), but does not include any assigned Prefixes.
-
-```
-{
-    "id": 1048,
-    "site": {
-        "id": 7,
-        "url": "http://localhost:8000/api/dcim/sites/7/",
-        "name": "Corporate HQ",
-        "slug": "corporate-hq"
-    },
-    "group": {
-        "id": 4,
-        "url": "http://localhost:8000/api/ipam/vlan-groups/4/",
-        "name": "Production",
-        "slug": "production"
-    },
-    "vid": 101,
-    "name": "Users-Floor1",
-    "tenant": null,
-    "status": [
-        1,
-        "Active"
-    ],
-    "role": {
-        "id": 9,
-        "url": "http://localhost:8000/api/ipam/roles/9/",
-        "name": "User Access",
-        "slug": "user-access"
-    },
-    "description": "",
-    "display_name": "101 (Users-Floor1)",
-    "custom_fields": {}
-}
-```
-
-Related objects (e.g. `ForeignKey` fields) are represented using a nested serializer. A nested serializer provides a minimal representation of an object, including only its URL and enough information to construct its name.
-
-When a base serializer includes one or more nested serializers, the hierarchical structure precludes it from being used for write operations. Thus, a flat representation of an object may be provided using a writable serializer. This serializer includes only raw database values and is not typically used for retrieval, except as part of the response to the creation or updating of an object.
-
-```
-{
-    "id": 1201,
-    "site": 7,
-    "group": 4,
-    "vid": 102,
-    "name": "Users-Floor2",
-    "tenant": null,
-    "status": 1,
-    "role": 9,
-    "description": ""
-}
-```
-
-# Pagination
-
-API responses which contain a list of objects (for example, a request to `/api/dcim/devices/`) will be paginated to avoid unnecessary overhead. The root JSON object will contain the following attributes:
-
-* `count`: The total count of all objects matching the query
-* `next`: A hyperlink to the next page of results (if applicable)
-* `previous`: A hyperlink to the previous page of results (if applicable)
-* `results`: The list of returned objects
-
-Here is an example of a paginated response:
-
-```
-HTTP 200 OK
-Allow: GET, POST, OPTIONS
-Content-Type: application/json
-Vary: Accept
-
-{
-    "count": 2861,
-    "next": "http://localhost:8000/api/dcim/devices/?limit=50&offset=50",
-    "previous": null,
-    "results": [
-        {
-            "id": 123,
-            "name": "DeviceName123",
-            ...
-        },
-        ...
-    ]
-}
-```
-
-The default page size derives from the [`PAGINATE_COUNT`](../configuration/optional-settings/#paginate_count) configuration setting, which defaults to 50. However, this can be overridden per request by specifying the desired `offset` and `limit` query parameters. For example, if you wish to retrieve a hundred devices at a time, you would make a request for:
-
-```
-http://localhost:8000/api/dcim/devices/?limit=100
-```
-
-The response will return devices 1 through 100. The URL provided in the `next` attribute of the response will return devices 101 through 200:
-
-```
-{
-    "count": 2861,
-    "next": "http://localhost:8000/api/dcim/devices/?limit=100&offset=100",
-    "previous": null,
-    "results": [...]
-}
-```
-
-The maximum number of objects that can be returned is limited by the [`MAX_PAGE_SIZE`](../configuration/optional-settings/#max_page_size) setting, which is 1000 by default. Setting this to `0` or `None` will remove the maximum limit. An API consumer can then pass `?limit=0` to retrieve _all_ matching objects with a single request.
-
-!!! warning
-    Disabling the page size limit introduces a potential for very resource-intensive requests, since one API request can effectively retrieve an entire table from the database.

docs/api/working-with-secrets.md

@@ -1,136 +0,0 @@
-As with most other objects, the NetBox API can be used to create, modify, and delete secrets. However, additional steps are needed to encrypt or decrypt secret data.
-
-# Generating a Session Key
-
-In order to encrypt or decrypt secret data, a session key must be attached to the API request. To generate a session key, send an authenticated request to the `/api/secrets/get-session-key/` endpoint with the private RSA key which matches your [UserKey](../data-model/secrets/#user-keys). The private key must be POSTed with the name `private_key`.
-
-```
-$ curl -X POST http://localhost:8000/api/secrets/get-session-key/ \
--H "Authorization: Token c639d619ecbeb1f3055c4141ba6870e20572edd7" \
--H "Accept: application/json; indent=4" \
---data-urlencode "private_key@<filename>"
-{
-    "session_key": "dyEnxlc9lnGzaOAV1dV/xqYPV63njIbdZYOgnAlGPHk="
-}
-```
-
-!!! note
-    To read the private key from a file, use the convention above. Alternatively, the private key can be read from an environment variable using `--data-urlencode "private_key=$PRIVATE_KEY"`.
-
-The request uses your private key to unlock your stored copy of the master key and generate a session key which can be attached in the `X-Session-Key` header of future API requests.
-
-# Retrieving Secrets
-
-A session key is not needed to retrieve unencrypted secrets: The secret is returned like any normal object with its `plaintext` field set to null.
-
-```
-$ curl http://localhost:8000/api/secrets/secrets/2587/ \
--H "Authorization: Token c639d619ecbeb1f3055c4141ba6870e20572edd7" \
--H "Accept: application/json; indent=4"
-{
-    "id": 2587,
-    "device": {
-        "id": 1827,
-        "url": "http://localhost:8000/api/dcim/devices/1827/",
-        "name": "MyTestDevice",
-        "display_name": "MyTestDevice"
-    },
-    "role": {
-        "id": 1,
-        "url": "http://localhost:8000/api/secrets/secret-roles/1/",
-        "name": "Login Credentials",
-        "slug": "login-creds"
-    },
-    "name": "admin",
-    "plaintext": null,
-    "hash": "pbkdf2_sha256$1000$G6mMFe4FetZQ$f+0itZbAoUqW5pd8+NH8W5rdp/2QNLIBb+LGdt4OSKA=",
-    "created": "2017-03-21",
-    "last_updated": "2017-03-21T19:28:44.265582Z"
-}
-```
-
-To decrypt a secret, we must include our session key in the `X-Session-Key` header:
-
-```
-$ curl http://localhost:8000/api/secrets/secrets/2587/ \
--H "Authorization: Token c639d619ecbeb1f3055c4141ba6870e20572edd7" \
--H "Accept: application/json; indent=4" \
--H "X-Session-Key: dyEnxlc9lnGzaOAV1dV/xqYPV63njIbdZYOgnAlGPHk="
-{
-    "id": 2587,
-    "device": {
-        "id": 1827,
-        "url": "http://localhost:8000/api/dcim/devices/1827/",
-        "name": "MyTestDevice",
-        "display_name": "MyTestDevice"
-    },
-    "role": {
-        "id": 1,
-        "url": "http://localhost:8000/api/secrets/secret-roles/1/",
-        "name": "Login Credentials",
-        "slug": "login-creds"
-    },
-    "name": "admin",
-    "plaintext": "foobar",
-    "hash": "pbkdf2_sha256$1000$G6mMFe4FetZQ$f+0itZbAoUqW5pd8+NH8W5rdp/2QNLIBb+LGdt4OSKA=",
-    "created": "2017-03-21",
-    "last_updated": "2017-03-21T19:28:44.265582Z"
-}
-```
-
-Lists of secrets can be decrypted in this manner as well:
-
-```
-$ curl http://localhost:8000/api/secrets/secrets/?limit=3 \
--H "Authorization: Token c639d619ecbeb1f3055c4141ba6870e20572edd7" \
--H "Accept: application/json; indent=4" \
--H "X-Session-Key: dyEnxlc9lnGzaOAV1dV/xqYPV63njIbdZYOgnAlGPHk="
-{
-    "count": 3482,
-    "next": "http://localhost:8000/api/secrets/secrets/?limit=3&offset=3",
-    "previous": null,
-    "results": [
-        {
-            "id": 2587,
-            ...
-            "plaintext": "foobar",
-            ...
-        },
-        {
-            "id": 2588,
-            ...
-            "plaintext": "MyP@ssw0rd!",
-            ...
-        },
-        {
-            "id": 2589,
-            ...
-            "plaintext": "AnotherSecret!",
-            ...
-        },
-    ]
-}
-```
-
-# Creating Secrets
-
-Session keys are also used to decrypt new or modified secrets. This is done by setting the `plaintext` field of the submitted object:
-
-```
-$ curl -X POST http://localhost:8000/api/secrets/secrets/ \
--H "Content-Type: application/json" \
--H "Authorization: Token c639d619ecbeb1f3055c4141ba6870e20572edd7" \
--H "Accept: application/json; indent=4" \
--H "X-Session-Key: dyEnxlc9lnGzaOAV1dV/xqYPV63njIbdZYOgnAlGPHk=" \
---data '{"device": 1827, "role": 1, "name": "backup", "plaintext": "Drowssap1"}'
-{
-    "id": 2590,
-    "device": 1827,
-    "role": 1,
-    "name": "backup",
-    "plaintext": "Drowssap1"
-}
-```
-
-!!! note
-    Don't forget to include the `Content-Type: application/json` header when making a POST request.

docs/configuration/optional-settings.md

@@ -38,22 +38,6 @@ BASE_PATH = 'netbox/'
 
 ---
 
-## CORS_ORIGIN_ALLOW_ALL
-
-Default: False
-
-If True, cross-origin resource sharing (CORS) requests will be accepted from all origins. If False, a whitelist will be used (see below).
-
----
-
-## CORS_ORIGIN_WHITELIST
-
-## CORS_ORIGIN_REGEX_WHITELIST
-
-These settings specify a list of origins that are authorized to make cross-site API requests. Use `CORS_ORIGIN_WHITELIST` to define a list of exact hostnames, or `CORS_ORIGIN_REGEX_WHITELIST` to define a set of regular expressions. (These settings have no effect if `CORS_ORIGIN_ALLOW_ALL` is True.)
-
----
-
 ## DEBUG
 
 Default: False
@@ -83,34 +67,6 @@ Enforcement of unique IP space can be toggled on a per-VRF basis. To enforce uni
 
 ---
 
-## LOGGING
-
-By default, all messages of INFO severity or higher will be logged to the console. Additionally, if `DEBUG` is False and email access has been configured, ERROR and CRITICAL messages will be emailed to the users defined in `ADMINS`.
-
-The Django framework on which NetBox runs allows for the customization of logging, e.g. to write logs to file. Please consult the [Django logging documentation](https://docs.djangoproject.com/en/1.11/topics/logging/) for more information on configuring this setting. Below is an example which will write all INFO and higher messages to a file:
-
-```
-LOGGING = {
-    'version': 1,
-    'disable_existing_loggers': False,
-    'handlers': {
-        'file': {
-            'level': 'INFO',
-            'class': 'logging.FileHandler',
-            'filename': '/var/log/netbox.log',
-        },
-    },
-    'loggers': {
-        'django': {
-            'handlers': ['file'],
-            'level': 'INFO',
-        },
-    },
-}
-```
-
----
-
 ## LOGIN_REQUIRED
 
 Default: False
@@ -127,14 +83,6 @@ Setting this to True will display a "maintenance mode" banner at the top of ever
 
 ---
 
-## MAX_PAGE_SIZE
-
-Default: 1000
-
-An API consumer can request an arbitrary number of objects by appending the "limit" parameter to the URL (e.g. `?limit=1000`). This setting defines the maximum limit. Setting it to `0` or `None` will allow an API consumer to request all objects by specifying `?limit=0`.
-
----
-
 ## NETBOX_USERNAME
 
 ## NETBOX_PASSWORD

docs/data-model/dcim.md

@@ -89,12 +89,9 @@ A device's platform is used to denote the type of software running on it. This c
 
 The assignment of platforms to devices is an optional feature, and may be disregarded if not desired.
 
-### Inventory Items
+### Modules
 
-Inventory items represent hardware components installed within a device, such as a power supply or CPU. Currently, these are used merely for inventory tracking, although future development might see their functionality expand. Each item can optionally be assigned a manufacturer.
+A device can be assigned modules which represent internal components. Currently, these are used merely for inventory tracking, although future development might see their functionality expand. Each module can optionally be assigned to a manufacturer.
-
-!!! note
-    Prior to version 2.0, inventory items were called modules.
 
 ### Components
 
@@ -112,3 +109,6 @@ Console ports connect only to console server ports, and power ports connect only
 Each interface is a assigned a form factor denoting its physical properties. Two special form factors exist: the "virtual" form factor can be used to designate logical interfaces (such as SVIs), and the "LAG" form factor can be used to desinate link aggregation groups to which physical interfaces can be assigned. Each interface can also be designated as management-only (for out-of-band management) and assigned a short description.
 
 Device bays represent the ability of a device to house child devices. For example, you might install four blade servers into a 2U chassis. The chassis would appear in the rack elevation as a 2U device with four device bays. Each server within it would be defined as a 0U device installed in one of the device bays. Child devices do not appear on rack elevations, but they are included in the "Non-Racked Devices" list within the rack view.
+
+!!! note
+    Child devices differ from modules in that they are still treated as independent devices, with their own console/power/data components, modules, and IP addresses. Modules, on the other hand, are parts within a device, such as a hard disk or power supply, which do not provide their own management plane.

docs/data-model/extras.md

@@ -119,14 +119,7 @@ Each line of the **device patterns** field represents a hierarchical layer withi
 ```
 core-switch-[abcd]
 dist-switch\d
-access-switch\d+;oob-switch\d+
+access-switch\d+,oob-switch\d+
 ```
 
 Note that you can combine multiple regexes onto one line using semicolons. The order in which regexes are listed on a line is significant: devices matching the first regex will be rendered first, and subsequent groups will be rendered to the right of those.
-
-# Image Attachments
-
-Certain objects within NetBox (namely sites, racks, and devices) can have photos or other images attached to them. (Note that _only_ image files are supported.) Each attachment may optionally be assigned a name; if omitted, the attachment will be represented by its file name.
-
-!!! note
-    If you experience a server error while attempting to upload an image attachment, verify that the system user NetBox runs as has write permission to the media root directory (`netbox/media/`).

docs/installation/docker.md

@@ -0,0 +1,51 @@
+This guide demonstrates how to build and run NetBox as a Docker container. It assumes that the latest versions of [Docker](https://www.docker.com/) and [docker-compose](https://docs.docker.com/compose/) are already installed in your host.
+
+# Quickstart
+
+To get NetBox up and running:
+
+```no-highlight
+# git clone -b master https://github.com/digitalocean/netbox.git
+# cd netbox
+# docker-compose up -d
+```
+
+The application will be available on http://localhost/ after a few minutes.
+
+Default credentials:
+
+* Username: **admin**
+* Password: **admin**
+
+# Configuration
+
+You can configure the app at runtime using variables (see `docker-compose.yml`). Possible environment variables include:
+
+* SUPERUSER_NAME
+* SUPERUSER_EMAIL
+* SUPERUSER_PASSWORD
+* ALLOWED_HOSTS
+* DB_NAME
+* DB_USER
+* DB_PASSWORD
+* DB_HOST
+* DB_PORT
+* SECRET_KEY
+* EMAIL_SERVER
+* EMAIL_PORT
+* EMAIL_USERNAME
+* EMAIL_PASSWORD
+* EMAIL_TIMEOUT
+* EMAIL_FROM
+* LOGIN_REQUIRED
+* MAINTENANCE_MODE
+* NETBOX_USERNAME
+* NETBOX_PASSWORD
+* PAGINATE_COUNT
+* TIME_ZONE
+* DATE_FORMAT
+* SHORT_DATE_FORMAT
+* TIME_FORMAT
+* SHORT_TIME_FORMAT
+* DATETIME_FORMAT
+* SHORT_DATETIME_FORMAT

docs/installation/ldap.md

@@ -1,4 +1,5 @@
-This guide explains how to implement LDAP authentication using an external server. User authentication will fall back to built-in Django users in the event of a failure.
+This guide explains how to implement LDAP authentication using an external server. User authentication will fall back to
+built-in Django users in the event of a failure.
 
 # Requirements
 
@@ -28,9 +29,6 @@ Create a file in the same directory as `configuration.py` (typically `netbox/net
 
 ## General Server Configuration
 
-!!! info
-    When using Windows Server 2012 you may need to specify a port on `AUTH_LDAP_SERVER_URI`. Use `3269` for secure, or `3268` for non-secure.
-
 ```python
 import ldap
 
@@ -54,9 +52,6 @@ LDAP_IGNORE_CERT_ERRORS = True
 
 ## User Authentication
 
-!!! info
-    When using Windows Server, `2012 AUTH_LDAP_USER_DN_TEMPLATE` should be set to None.
-
 ```python
 from django_auth_ldap.config import LDAPSearch
 
@@ -104,16 +99,3 @@ AUTH_LDAP_FIND_GROUP_PERMS = True
 AUTH_LDAP_CACHE_GROUPS = True
 AUTH_LDAP_GROUP_CACHE_TIMEOUT = 3600
 ```
-
-* `is_active` - All users must be mapped to at least this group to enable authentication. Without this, users cannot log in.
-* `is_staff` - Users mapped to this group are enabled for access to the administration tools; this is the equivalent of checking the "staff status" box on a manually created user. This doesn't grant any specific permissions.
-* `is_superuser` - Users mapped to this group will be granted superuser status. Superusers are implicitly granted all permissions.
-
-It is also possible map user attributes to Django attributes:
-
-```python
-AUTH_LDAP_USER_ATTR_MAP = {
-    "first_name": "givenName",
-    "last_name": "sn",
-}
-```

docs/installation/netbox.md

@@ -1,28 +1,26 @@
 # Installation
 
-**Ubuntu**
+**Debian/Ubuntu**
 
 Python 3:
 
 ```no-highlight
-# apt-get install -y python3 python3-dev python3-pip libxml2-dev libxslt1-dev libffi-dev graphviz libpq-dev libssl-dev zlib1g-dev
+# apt-get install -y python3 python3-dev python3-pip libxml2-dev libxslt1-dev libffi-dev graphviz libpq-dev libssl-dev
 ```
 
 Python 2:
 
 ```no-highlight
-# apt-get install -y python2.7 python-dev python-pip libxml2-dev libxslt1-dev libffi-dev graphviz libpq-dev libssl-dev zlib1g-dev
+# apt-get install -y python2.7 python-dev python-pip libxml2-dev libxslt1-dev libffi-dev graphviz libpq-dev libssl-dev
 ```
 
-**CentOS**
+**CentOS/RHEL**
 
 Python 3:
 
 ```no-highlight
 # yum install -y epel-release
-# yum install -y gcc python34 python34-devel python34-setuptools libxml2-devel libxslt-devel libffi-devel graphviz openssl-devel
+# yum install -y gcc python3 python3-devel python3-pip libxml2-devel libxslt-devel libffi-devel graphviz openssl-devel
-# easy_install-3.4 pip
-# ln -s -f python3.4 /usr/bin/python
 ```
 
 Python 2:
@@ -56,13 +54,13 @@ Create the base directory for the NetBox installation. For this guide, we'll use
 
 If `git` is not already installed, install it:
 
-**Ubuntu**
+**Debian/Ubuntu**
 
 ```no-highlight
 # apt-get install -y git
 ```
 
-**CentOS**
+**CentOS/RHEL**
 
 ```no-highlight
 # yum install -y git
@@ -85,14 +83,6 @@ Checking connectivity... done.
 
 Install the required Python packages using pip. (If you encounter any compilation errors during this step, ensure that you've installed all of the system dependencies listed above.)
 
-Python 3:
-
-```no-highlight
-# pip3 install -r requirements.txt
-```
-
-Python 2:
-
 ```no-highlight
 # pip install -r requirements.txt
 ```
@@ -149,14 +139,11 @@ You may use the script located at `netbox/generate_secret_key.py` to generate a
 
 # Run Database Migrations
 
-!!! warning
+Before NetBox can run, we need to install the database schema. This is done by running `./manage.py migrate` from the `netbox` directory (`/opt/netbox/netbox/` in our example):
-    The examples on the rest of this page call the `python` executable, which will be Python2 on most systems. Replace this with `python3` if you're running NetBox on Python3.
-
-Before NetBox can run, we need to install the database schema. This is done by running `python manage.py migrate` from the `netbox` directory (`/opt/netbox/netbox/` in our example):
 
 ```no-highlight
 # cd /opt/netbox/netbox/
-# python manage.py migrate
+# ./manage.py migrate
 Operations to perform:
   Apply all migrations: dcim, sessions, admin, ipam, utilities, auth, circuits, contenttypes, extras, secrets, users
 Running migrations:
@@ -174,7 +161,7 @@ If this step results in a PostgreSQL authentication error, ensure that the usern
 NetBox does not come with any predefined user accounts. You'll need to create a super user to be able to log into NetBox:
 
 ```no-highlight
-# python manage.py createsuperuser
+# ./manage.py createsuperuser
 Username: admin
 Email address: admin@example.com
 Password:
@@ -185,7 +172,7 @@ Superuser created successfully.
 # Collect Static Files
 
 ```no-highlight
-# python manage.py collectstatic --no-input
+# ./manage.py collectstatic
 
 You have requested to collect static files at the destination
 location as specified in your settings:
@@ -206,7 +193,7 @@ NetBox ships with some initial data to help you get started: RIR definitions, co
     This step is optional. It's perfectly fine to start using NetBox without using this initial data if you'd rather create everything from scratch.
 
 ```no-highlight
-# python manage.py loaddata initial_data
+# ./manage.py loaddata initial_data
 Installed 43 object(s) from 4 fixture(s)
 ```
 
@@ -215,7 +202,7 @@ Installed 43 object(s) from 4 fixture(s)
 At this point, NetBox should be able to run. We can verify this by starting a development instance:
 
 ```no-highlight
-# python manage.py runserver 0.0.0.0:8000 --insecure
+# ./manage.py runserver 0.0.0.0:8000 --insecure
 Performing system checks...
 
 System check identified no issues (0 silenced).

docs/installation/postgresql.md

@@ -1,21 +1,17 @@
 NetBox requires a PostgreSQL database to store data. (Please note that MySQL is not supported, as NetBox leverages PostgreSQL's built-in [network address types](https://www.postgresql.org/docs/9.1/static/datatype-net-types.html).)
 
-!!! note
-    The installation instructions provided here have been tested to work on Ubuntu 16.04 and CentOS 6.9. The particular commands needed to install dependencies on other distributions may vary significantly. Unfortunately, this is outside the control of the NetBox maintainers. Please consult your distribution's documentation for assistance with any errors.
-
 # Installation
 
-**Ubuntu**
+**Debian/Ubuntu**
 
 ```no-highlight
-# apt-get update
+# apt-get install -y postgresql libpq-dev python-psycopg2
-# apt-get install -y postgresql libpq-dev
 ```
 
-**CentOS**
+**CentOS/RHEL**
 
 ```no-highlight
-# yum install -y postgresql postgresql-server postgresql-devel
+# yum install -y postgresql postgresql-server postgresql-devel python-psycopg2
 # postgresql-setup initdb
 ```
 

docs/installation/upgrading.md

@@ -52,27 +52,12 @@ Once the new code is in place, run the upgrade script (which may need to be run
 # ./upgrade.sh
 ```
 
-!!! warning
-    The upgrade script will prefer Python3 and pip3 if both executables are available. To force it to use Python2 and pip, use the `-2` argument as below.
-
-```no-highlight
-# ./upgrade.sh -2
-```
-
 This script:
 
 * Installs or upgrades any new required Python packages
 * Applies any database migrations that were included in the release
 * Collects all static files to be served by the HTTP service
 
-!!! note
-    It's possible that the upgrade script will display a notice warning of unreflected database migrations:
-
-        Your models have changes that are not yet reflected in a migration, and so won't be applied.
-        Run 'manage.py makemigrations' to make new migrations, and then re-run 'manage.py migrate' to apply them.
-
-    This may occur due to semantic differences in environment, and can be safely ignored. Never attempt to create new migrations unless you are intentionally modifying the database schema.
-
 # Restart the WSGI Service
 
 Finally, restart the WSGI service to run the new code. If you followed this guide for the initial installation, this is done using `supervisorctl`:

docs/installation/web-server.md

@@ -3,7 +3,7 @@
 We'll set up a simple WSGI front end using [gunicorn](http://gunicorn.org/) for the purposes of this guide. For web servers, we provide example configurations for both [nginx](https://www.nginx.com/resources/wiki/) and [Apache](http://httpd.apache.org/docs/2.4). (You are of course free to use whichever combination of HTTP and WSGI services you'd like.) We'll also use [supervisord](http://supervisord.org/) to enable service persistence.
 
 !!! info
-    For the sake of brevity, only Ubuntu 16.04 instructions are provided here, but this sort of web server and WSGI configuration is not unique to NetBox. Please consult your distribution's documentation for assistance if needed.
+    Only Debian/Ubuntu instructions are provided here, but the installation process for CentOS/RHEL does not differ much. Please consult the documentation for those distributions for details.
 
 ```no-highlight
 # apt-get install -y gunicorn supervisor
@@ -25,7 +25,7 @@ server {
 
     server_name netbox.example.com;
 
-    client_max_body_size 25m;
+    access_log off;
 
     location /static/ {
         alias /opt/netbox/netbox/static/;
@@ -73,9 +73,6 @@ Once Apache is installed, proceed with the following configuration (Be sure to m
 
     Alias /static /opt/netbox/netbox/static
 
-    # Needed to allow token-based API authentication
-    WSGIPassAuthorization on
-
     <Directory /opt/netbox/netbox/static>
         Options Indexes FollowSymLinks MultiViews
         AllowOverride None

mkdocs.yml

@@ -8,6 +8,7 @@ pages:
         - 'Web Server': 'installation/web-server.md'
         - 'LDAP (Optional)': 'installation/ldap.md'
         - 'Upgrading': 'installation/upgrading.md'
+        - 'Alternate Install: Docker': 'installation/docker.md'
     - 'Configuration':
         - 'Mandatory Settings': 'configuration/mandatory-settings.md'
         - 'Optional Settings': 'configuration/optional-settings.md'
@@ -18,11 +19,7 @@ pages:
         - 'Secrets': 'data-model/secrets.md'
         - 'Tenancy': 'data-model/tenancy.md'
         - 'Extras': 'data-model/extras.md'
-    - 'API':
+    - 'API Integration': 'api-integration.md'
-        - 'Overview': 'api/overview.md'
-        - 'Authentication': 'api/authentication.md'
-        - 'Working with Secrets': 'api/working-with-secrets.md'
-        - 'Examples': 'api/examples.md'
 
 markdown_extensions:
     - admonition:

netbox/circuits/admin.py

@@ -0,0 +1,29 @@
+from django.contrib import admin
+
+from .models import Provider, CircuitType, Circuit
+
+
+@admin.register(Provider)
+class ProviderAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+    list_display = ['name', 'slug', 'asn']
+
+
+@admin.register(CircuitType)
+class CircuitTypeAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+    list_display = ['name', 'slug']
+
+
+@admin.register(Circuit)
+class CircuitAdmin(admin.ModelAdmin):
+    list_display = ['cid', 'provider', 'type', 'tenant', 'install_date', 'commit_rate_human']
+    list_filter = ['provider', 'type', 'tenant']
+
+    def get_queryset(self, request):
+        qs = super(CircuitAdmin, self).get_queryset(request)
+        return qs.select_related('provider', 'type', 'tenant')

netbox/circuits/api/serializers.py

@@ -1,120 +1,72 @@
-from __future__ import unicode_literals
-
 from rest_framework import serializers
 
 from circuits.models import Provider, Circuit, CircuitTermination, CircuitType
-from dcim.api.serializers import NestedSiteSerializer, InterfaceSerializer
+from dcim.api.serializers import SiteNestedSerializer, InterfaceNestedSerializer
-from extras.api.customfields import CustomFieldModelSerializer
+from extras.api.serializers import CustomFieldSerializer
-from tenancy.api.serializers import NestedTenantSerializer
+from tenancy.api.serializers import TenantNestedSerializer
-from utilities.api import ModelValidationMixin
 
 
 #
 # Providers
 #
 
-class ProviderSerializer(CustomFieldModelSerializer):
+class ProviderSerializer(CustomFieldSerializer, serializers.ModelSerializer):
 
     class Meta:
         model = Provider
-        fields = [
+        fields = ['id', 'name', 'slug', 'asn', 'account', 'portal_url', 'noc_contact', 'admin_contact', 'comments',
-            'id', 'name', 'slug', 'asn', 'account', 'portal_url', 'noc_contact', 'admin_contact', 'comments',
+                  'custom_fields']
-            'custom_fields',
-        ]
 
 
-class NestedProviderSerializer(serializers.ModelSerializer):
+class ProviderNestedSerializer(ProviderSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='circuits-api:provider-detail')
 
-    class Meta:
+    class Meta(ProviderSerializer.Meta):
-        model = Provider
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
-
-
-class WritableProviderSerializer(CustomFieldModelSerializer):
-
-    class Meta:
-        model = Provider
-        fields = [
-            'id', 'name', 'slug', 'asn', 'account', 'portal_url', 'noc_contact', 'admin_contact', 'comments',
-            'custom_fields',
-        ]
 
 
 #
 # Circuit types
 #
 
-class CircuitTypeSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class CircuitTypeSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = CircuitType
         fields = ['id', 'name', 'slug']
 
 
-class NestedCircuitTypeSerializer(serializers.ModelSerializer):
+class CircuitTypeNestedSerializer(CircuitTypeSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='circuits-api:circuittype-detail')
 
-    class Meta:
+    class Meta(CircuitTypeSerializer.Meta):
-        model = CircuitType
+        pass
-        fields = ['id', 'url', 'name', 'slug']
 
 
 #
 # Circuits
 #
 
-class CircuitSerializer(CustomFieldModelSerializer):
-    provider = NestedProviderSerializer()
-    type = NestedCircuitTypeSerializer()
-    tenant = NestedTenantSerializer()
-
-    class Meta:
-        model = Circuit
-        fields = [
-            'id', 'cid', 'provider', 'type', 'tenant', 'install_date', 'commit_rate', 'description', 'comments',
-            'custom_fields',
-        ]
-
-
-class NestedCircuitSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='circuits-api:circuit-detail')
-
-    class Meta:
-        model = Circuit
-        fields = ['id', 'url', 'cid']
-
-
-class WritableCircuitSerializer(CustomFieldModelSerializer):
-
-    class Meta:
-        model = Circuit
-        fields = [
-            'id', 'cid', 'provider', 'type', 'tenant', 'install_date', 'commit_rate', 'description', 'comments',
-            'custom_fields',
-        ]
-
-
-#
-# Circuit Terminations
-#
-
 class CircuitTerminationSerializer(serializers.ModelSerializer):
-    circuit = NestedCircuitSerializer()
+    site = SiteNestedSerializer()
-    site = NestedSiteSerializer()
+    interface = InterfaceNestedSerializer()
-    interface = InterfaceSerializer()
 
     class Meta:
         model = CircuitTermination
-        fields = [
+        fields = ['id', 'term_side', 'site', 'interface', 'port_speed', 'upstream_speed', 'xconnect_id', 'pp_info']
-            'id', 'circuit', 'term_side', 'site', 'interface', 'port_speed', 'upstream_speed', 'xconnect_id', 'pp_info',
-        ]
 
 
-class WritableCircuitTerminationSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class CircuitSerializer(CustomFieldSerializer, serializers.ModelSerializer):
+    provider = ProviderNestedSerializer()
+    type = CircuitTypeNestedSerializer()
+    tenant = TenantNestedSerializer()
+    terminations = CircuitTerminationSerializer(many=True)
 
     class Meta:
-        model = CircuitTermination
+        model = Circuit
-        fields = [
+        fields = ['id', 'cid', 'provider', 'type', 'tenant', 'install_date', 'commit_rate', 'description', 'comments',
-            'id', 'circuit', 'term_side', 'site', 'interface', 'port_speed', 'upstream_speed', 'xconnect_id', 'pp_info',
+                  'terminations', 'custom_fields']
-        ]
+
+
+class CircuitNestedSerializer(CircuitSerializer):
+
+    class Meta(CircuitSerializer.Meta):
+        fields = ['id', 'cid']

netbox/circuits/api/urls.py

@@ -1,28 +1,25 @@
-from __future__ import unicode_literals
+from django.conf.urls import url
 
-from rest_framework import routers
+from extras.models import GRAPH_TYPE_PROVIDER
+from extras.api.views import GraphListView
 
-from . import views
+from .views import *
 
 
-class CircuitsRootView(routers.APIRootView):
+urlpatterns = [
-    """
-    Circuits API root view
-    """
-    def get_view_name(self):
-        return 'Circuits'
 
+    # Providers
+    url(r'^providers/$', ProviderListView.as_view(), name='provider_list'),
+    url(r'^providers/(?P<pk>\d+)/$', ProviderDetailView.as_view(), name='provider_detail'),
+    url(r'^providers/(?P<pk>\d+)/graphs/$', GraphListView.as_view(), {'type': GRAPH_TYPE_PROVIDER},
+        name='provider_graphs'),
 
-router = routers.DefaultRouter()
+    # Circuit types
-router.APIRootView = CircuitsRootView
+    url(r'^circuit-types/$', CircuitTypeListView.as_view(), name='circuittype_list'),
+    url(r'^circuit-types/(?P<pk>\d+)/$', CircuitTypeDetailView.as_view(), name='circuittype_detail'),
 
-# Providers
+    # Circuits
-router.register(r'providers', views.ProviderViewSet)
+    url(r'^circuits/$', CircuitListView.as_view(), name='circuit_list'),
+    url(r'^circuits/(?P<pk>\d+)/$', CircuitDetailView.as_view(), name='circuit_detail'),
 
-# Circuits
+]
-router.register(r'circuit-types', views.CircuitTypeViewSet)
-router.register(r'circuits', views.CircuitViewSet)
-router.register(r'circuit-terminations', views.CircuitTerminationViewSet)
-
-app_name = 'circuits-api'
-urlpatterns = router.urls

netbox/circuits/api/views.py

@@ -1,68 +1,58 @@
-from __future__ import unicode_literals
+from rest_framework import generics
 
-from rest_framework.decorators import detail_route
+from circuits.models import Provider, CircuitType, Circuit
-from rest_framework.response import Response
+from circuits.filters import CircuitFilter
-from rest_framework.viewsets import ModelViewSet
 
-from django.shortcuts import get_object_or_404
+from extras.api.views import CustomFieldModelAPIView
-
-from circuits import filters
-from circuits.models import Provider, CircuitTermination, CircuitType, Circuit
-from extras.models import Graph, GRAPH_TYPE_PROVIDER
-from extras.api.serializers import RenderedGraphSerializer
-from extras.api.views import CustomFieldModelViewSet
-from utilities.api import WritableSerializerMixin
 from . import serializers
 
 
-#
+class ProviderListView(CustomFieldModelAPIView, generics.ListAPIView):
-# Providers
+    """
-#
+    List all providers
-
+    """
-class ProviderViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+    queryset = Provider.objects.prefetch_related('custom_field_values__field')
-    queryset = Provider.objects.all()
     serializer_class = serializers.ProviderSerializer
-    write_serializer_class = serializers.WritableProviderSerializer
-    filter_class = filters.ProviderFilter
 
-    @detail_route()
+
-    def graphs(self, request, pk=None):
+class ProviderDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
-        A convenience method for rendering graphs for a particular provider.
+    Retrieve a single provider
     """
-        provider = get_object_or_404(Provider, pk=pk)
+    queryset = Provider.objects.prefetch_related('custom_field_values__field')
-        queryset = Graph.objects.filter(type=GRAPH_TYPE_PROVIDER)
+    serializer_class = serializers.ProviderSerializer
-        serializer = RenderedGraphSerializer(queryset, many=True, context={'graphed_object': provider})
-        return Response(serializer.data)
 
 
-#
+class CircuitTypeListView(generics.ListAPIView):
-#  Circuit Types
+    """
-#
+    List all circuit types
-
+    """
-class CircuitTypeViewSet(ModelViewSet):
     queryset = CircuitType.objects.all()
     serializer_class = serializers.CircuitTypeSerializer
-    filter_class = filters.CircuitTypeFilter
 
 
-#
+class CircuitTypeDetailView(generics.RetrieveAPIView):
-# Circuits
+    """
-#
+    Retrieve a single circuit type
+    """
+    queryset = CircuitType.objects.all()
+    serializer_class = serializers.CircuitTypeSerializer
 
-class CircuitViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+
-    queryset = Circuit.objects.select_related('type', 'tenant', 'provider')
+class CircuitListView(CustomFieldModelAPIView, generics.ListAPIView):
+    """
+    List circuits (filterable)
+    """
+    queryset = Circuit.objects.select_related('type', 'tenant', 'provider')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.CircuitSerializer
-    write_serializer_class = serializers.WritableCircuitSerializer
+    filter_class = CircuitFilter
-    filter_class = filters.CircuitFilter
 
 
-#
+class CircuitDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
-# Circuit Terminations
+    """
-#
+    Retrieve a single circuit
-
+    """
-class CircuitTerminationViewSet(WritableSerializerMixin, ModelViewSet):
+    queryset = Circuit.objects.select_related('type', 'tenant', 'provider')\
-    queryset = CircuitTermination.objects.select_related('circuit', 'site', 'interface__device')
+        .prefetch_related('custom_field_values__field')
-    serializer_class = serializers.CircuitTerminationSerializer
+    serializer_class = serializers.CircuitSerializer
-    write_serializer_class = serializers.WritableCircuitTerminationSerializer
-    filter_class = filters.CircuitTerminationFilter

netbox/circuits/apps.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from django.apps import AppConfig
 
 

netbox/circuits/constants.py

@@ -1,10 +0,0 @@
-from __future__ import unicode_literals
-
-
-# CircuitTermination sides
-TERM_SIDE_A = 'A'
-TERM_SIDE_Z = 'Z'
-TERM_SIDE_CHOICES = (
-    (TERM_SIDE_A, 'A'),
-    (TERM_SIDE_Z, 'Z'),
-)

netbox/circuits/filters.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 import django_filters
 
 from django.db.models import Q
@@ -8,7 +6,8 @@ from dcim.models import Site
 from extras.filters import CustomFieldFilterSet
 from tenancy.models import Tenant
 from utilities.filters import NullableModelMultipleChoiceFilter, NumericInFilter
-from .models import Provider, Circuit, CircuitTermination, CircuitType
+
+from .models import Provider, Circuit, CircuitType
 
 
 class ProviderFilter(CustomFieldFilterSet, django_filters.FilterSet):
@@ -31,7 +30,7 @@ class ProviderFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
     class Meta:
         model = Provider
-        fields = ['name', 'slug', 'asn', 'account']
+        fields = ['name', 'account', 'asn']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -39,19 +38,10 @@ class ProviderFilter(CustomFieldFilterSet, django_filters.FilterSet):
         return queryset.filter(
             Q(name__icontains=value) |
             Q(account__icontains=value) |
-            Q(noc_contact__icontains=value) |
-            Q(admin_contact__icontains=value) |
             Q(comments__icontains=value)
         )
 
 
-class CircuitTypeFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = CircuitType
-        fields = ['name', 'slug']
-
-
 class CircuitFilter(CustomFieldFilterSet, django_filters.FilterSet):
     id__in = NumericInFilter(name='id', lookup_expr='in')
     q = django_filters.CharFilter(
@@ -59,6 +49,7 @@ class CircuitFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Search',
     )
     provider_id = django_filters.ModelMultipleChoiceFilter(
+        name='provider',
         queryset=Provider.objects.all(),
         label='Provider (ID)',
     )
@@ -69,6 +60,7 @@ class CircuitFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Provider (slug)',
     )
     type_id = django_filters.ModelMultipleChoiceFilter(
+        name='type',
         queryset=CircuitType.objects.all(),
         label='Circuit type (ID)',
     )
@@ -79,6 +71,7 @@ class CircuitFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Circuit type (slug)',
     )
     tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         label='Tenant (ID)',
     )
@@ -102,7 +95,7 @@ class CircuitFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
     class Meta:
         model = Circuit
-        fields = ['cid', 'install_date', 'commit_rate']
+        fields = ['install_date']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -114,37 +107,3 @@ class CircuitFilter(CustomFieldFilterSet, django_filters.FilterSet):
             Q(description__icontains=value) |
             Q(comments__icontains=value)
         ).distinct()
-
-
-class CircuitTerminationFilter(django_filters.FilterSet):
-    q = django_filters.CharFilter(
-        method='search',
-        label='Search',
-    )
-    circuit_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=Circuit.objects.all(),
-        label='Circuit',
-    )
-    site_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=Site.objects.all(),
-        label='Site (ID)',
-    )
-    site = django_filters.ModelMultipleChoiceFilter(
-        name='site__slug',
-        queryset=Site.objects.all(),
-        to_field_name='slug',
-        label='Site (slug)',
-    )
-
-    class Meta:
-        model = CircuitTermination
-        fields = ['term_side', 'port_speed', 'upstream_speed', 'xconnect_id']
-
-    def search(self, queryset, name, value):
-        if not value.strip():
-            return queryset
-        return queryset.filter(
-            Q(circuit__cid__icontains=value) |
-            Q(xconnect_id__icontains=value) |
-            Q(pp_info__icontains=value)
-        ).distinct()

netbox/circuits/forms.py

@@ -1,15 +1,12 @@
-from __future__ import unicode_literals
-
 from django import forms
 from django.db.models import Count
 
-from dcim.models import Site, Device, Interface, Rack
+from dcim.models import Site, Device, Interface, Rack, VIRTUAL_IFACE_TYPES
 from extras.forms import CustomFieldForm, CustomFieldBulkEditForm, CustomFieldFilterForm
-from tenancy.forms import TenancyForm
 from tenancy.models import Tenant
 from utilities.forms import (
-    APISelect, BootstrapMixin, ChainedFieldsMixin, ChainedModelChoiceField, CommentField, FilterChoiceField,
+    APISelect, BootstrapMixin, BulkImportForm, CommentField, CSVDataField, FilterChoiceField, Livesearch, SmallTextarea,
-    SmallTextarea, SlugField,
+    SlugField,
 )
 
 from .models import Circuit, CircuitTermination, CircuitType, Provider
@@ -39,18 +36,15 @@ class ProviderForm(BootstrapMixin, CustomFieldForm):
         }
 
 
-class ProviderCSVForm(forms.ModelForm):
+class ProviderFromCSVForm(forms.ModelForm):
-    slug = SlugField()
 
     class Meta:
         model = Provider
-        fields = ['name', 'slug', 'asn', 'account', 'portal_url', 'comments']
+        fields = ['name', 'slug', 'asn', 'account', 'portal_url']
-        help_texts = {
+
-            'name': 'Provider name',
+
-            'asn': '32-bit autonomous system number',
+class ProviderImportForm(BootstrapMixin, BulkImportForm):
-            'portal_url': 'Portal URL',
+    csv = CSVDataField(csv_form=ProviderFromCSVForm)
-            'comments': 'Free-form comments',
-        }
 
 
 class ProviderBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
@@ -89,15 +83,12 @@ class CircuitTypeForm(BootstrapMixin, forms.ModelForm):
 # Circuits
 #
 
-class CircuitForm(BootstrapMixin, TenancyForm, CustomFieldForm):
+class CircuitForm(BootstrapMixin, CustomFieldForm):
     comments = CommentField()
 
     class Meta:
         model = Circuit
-        fields = [
+        fields = ['cid', 'type', 'provider', 'tenant', 'install_date', 'commit_rate', 'description', 'comments']
-            'cid', 'type', 'provider', 'install_date', 'commit_rate', 'description', 'tenant_group', 'tenant',
-            'comments',
-        ]
         help_texts = {
             'cid': "Unique circuit ID",
             'install_date': "Format: YYYY-MM-DD",
@@ -105,36 +96,21 @@ class CircuitForm(BootstrapMixin, TenancyForm, CustomFieldForm):
         }
 
 
-class CircuitCSVForm(forms.ModelForm):
+class CircuitFromCSVForm(forms.ModelForm):
-    provider = forms.ModelChoiceField(
+    provider = forms.ModelChoiceField(Provider.objects.all(), to_field_name='name',
-        queryset=Provider.objects.all(),
+                                      error_messages={'invalid_choice': 'Provider not found.'})
-        to_field_name='name',
+    type = forms.ModelChoiceField(CircuitType.objects.all(), to_field_name='name',
-        help_text='Name of parent provider',
+                                  error_messages={'invalid_choice': 'Invalid circuit type.'})
-        error_messages={
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
-            'invalid_choice': 'Provider not found.'
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
-        }
-    )
-    type = forms.ModelChoiceField(
-        queryset=CircuitType.objects.all(),
-        to_field_name='name',
-        help_text='Type of circuit',
-        error_messages={
-            'invalid_choice': 'Invalid circuit type.'
-        }
-    )
-    tenant = forms.ModelChoiceField(
-        queryset=Tenant.objects.all(),
-        required=False,
-        to_field_name='name',
-        help_text='Name of assigned tenant',
-        error_messages={
-            'invalid_choice': 'Tenant not found.'
-        }
-    )
 
     class Meta:
         model = Circuit
-        fields = ['cid', 'provider', 'type', 'tenant', 'install_date', 'commit_rate', 'description', 'comments']
+        fields = ['cid', 'provider', 'type', 'tenant', 'install_date', 'commit_rate', 'description']
+
+
+class CircuitImportForm(BootstrapMixin, BulkImportForm):
+    csv = CSVDataField(csv_form=CircuitFromCSVForm)
 
 
 class CircuitBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
@@ -176,18 +152,15 @@ class CircuitFilterForm(BootstrapMixin, CustomFieldFilterForm):
 # Circuit terminations
 #
 
-class CircuitTerminationForm(BootstrapMixin, ChainedFieldsMixin, forms.ModelForm):
+class CircuitTerminationForm(BootstrapMixin, forms.ModelForm):
     site = forms.ModelChoiceField(
         queryset=Site.objects.all(),
         widget=forms.Select(
             attrs={'filter-for': 'rack'}
         )
     )
-    rack = ChainedModelChoiceField(
+    rack = forms.ModelChoiceField(
         queryset=Rack.objects.all(),
-        chains=(
-            ('site', 'site'),
-        ),
         required=False,
         label='Rack',
         widget=APISelect(
@@ -195,12 +168,8 @@ class CircuitTerminationForm(BootstrapMixin, ChainedFieldsMixin, forms.ModelForm
             attrs={'filter-for': 'device', 'nullable': 'true'}
         )
     )
-    device = ChainedModelChoiceField(
+    device = forms.ModelChoiceField(
         queryset=Device.objects.all(),
-        chains=(
-            ('site', 'site'),
-            ('rack', 'rack'),
-        ),
         required=False,
         label='Device',
         widget=APISelect(
@@ -209,27 +178,29 @@ class CircuitTerminationForm(BootstrapMixin, ChainedFieldsMixin, forms.ModelForm
             attrs={'filter-for': 'interface'}
         )
     )
-    interface = ChainedModelChoiceField(
+    livesearch = forms.CharField(
-        queryset=Interface.objects.connectable().select_related(
+        required=False,
-            'circuit_termination', 'connected_as_a', 'connected_as_b'
+        label='Device',
-        ),
+        widget=Livesearch(
-        chains=(
+            query_key='q',
-            ('device', 'device'),
+            query_url='dcim-api:device_list',
-        ),
+            field_to_update='device'
+        )
+    )
+    interface = forms.ModelChoiceField(
+        queryset=Interface.objects.all(),
         required=False,
         label='Interface',
         widget=APISelect(
-            api_url='/api/dcim/interfaces/?device_id={{device}}&type=physical',
+            api_url='/api/dcim/devices/{{device}}/interfaces/?type=physical',
             disabled_indicator='is_connected'
         )
     )
 
     class Meta:
         model = CircuitTermination
-        fields = [
+        fields = ['term_side', 'site', 'rack', 'device', 'livesearch', 'interface', 'port_speed', 'upstream_speed',
-            'term_side', 'site', 'rack', 'device', 'interface', 'port_speed', 'upstream_speed', 'xconnect_id',
+                  'xconnect_id', 'pp_info']
-            'pp_info',
-        ]
         help_texts = {
             'port_speed': "Physical circuit speed",
             'xconnect_id': "ID of the local cross-connect",
@@ -241,22 +212,49 @@ class CircuitTerminationForm(BootstrapMixin, ChainedFieldsMixin, forms.ModelForm
 
     def __init__(self, *args, **kwargs):
 
-        # Initialize helper selectors
-        instance = kwargs.get('instance')
-        if instance and instance.interface is not None:
-            initial = kwargs.get('initial', {})
-            initial['rack'] = instance.interface.device.rack
-            initial['device'] = instance.interface.device
-            kwargs['initial'] = initial
-
         super(CircuitTerminationForm, self).__init__(*args, **kwargs)
 
-        # Mark connected interfaces as disabled
+        # If an interface has been assigned, initialize rack and device
-        self.fields['interface'].choices = []
+        if self.instance.interface:
-        for iface in self.fields['interface'].queryset:
+            self.initial['rack'] = self.instance.interface.device.rack
-            self.fields['interface'].choices.append(
+            self.initial['device'] = self.instance.interface.device
+
+        # Limit rack choices
+        if self.is_bound:
+            self.fields['rack'].queryset = Rack.objects.filter(site__pk=self.data['site'])
+        elif self.initial.get('site'):
+            self.fields['rack'].queryset = Rack.objects.filter(site=self.initial['site'])
+        else:
+            self.fields['rack'].choices = []
+
+        # Limit device choices
+        if self.is_bound and self.data.get('rack'):
+            self.fields['device'].queryset = Device.objects.filter(rack=self.data['rack'])
+        elif self.initial.get('rack'):
+            self.fields['device'].queryset = Device.objects.filter(rack=self.initial['rack'])
+        else:
+            self.fields['device'].choices = []
+
+        # Limit interface choices
+        if self.is_bound and self.data.get('device'):
+            interfaces = Interface.objects.filter(device=self.data['device']).exclude(
+                form_factor__in=VIRTUAL_IFACE_TYPES
+            ).select_related(
+                'circuit_termination', 'connected_as_a', 'connected_as_b'
+            )
+            self.fields['interface'].widget.attrs['initial'] = self.data.get('interface')
+        elif self.initial.get('device'):
+            interfaces = Interface.objects.filter(device=self.initial['device']).exclude(
+                form_factor__in=VIRTUAL_IFACE_TYPES
+            ).select_related(
+                'circuit_termination', 'connected_as_a', 'connected_as_b'
+            )
+            self.fields['interface'].widget.attrs['initial'] = self.initial.get('interface')
+        else:
+            interfaces = []
+        self.fields['interface'].choices = [
             (iface.id, {
                 'label': iface.name,
-                    'disabled': iface.is_connected and iface.pk != self.initial.get('interface'),
+                'disabled': iface.is_connected and iface.id != self.fields['interface'].widget.attrs.get('initial'),
-                })
+            }) for iface in interfaces
-            )
+        ]

netbox/circuits/migrations/0008_circuittermination_interface_protect_on_delete.py

@@ -1,21 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11 on 2017-04-19 17:17
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('circuits', '0007_circuit_add_description'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='circuittermination',
-            name='interface',
-            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='circuit_termination', to='dcim.Interface'),
-        ),
-    ]

netbox/circuits/migrations/0009_unicode_literals.py

@@ -1,81 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11 on 2017-05-24 15:34
-from __future__ import unicode_literals
-
-import dcim.fields
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('circuits', '0008_circuittermination_interface_protect_on_delete'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='circuit',
-            name='cid',
-            field=models.CharField(max_length=50, verbose_name='Circuit ID'),
-        ),
-        migrations.AlterField(
-            model_name='circuit',
-            name='commit_rate',
-            field=models.PositiveIntegerField(blank=True, null=True, verbose_name='Commit rate (Kbps)'),
-        ),
-        migrations.AlterField(
-            model_name='circuit',
-            name='install_date',
-            field=models.DateField(blank=True, null=True, verbose_name='Date installed'),
-        ),
-        migrations.AlterField(
-            model_name='circuittermination',
-            name='port_speed',
-            field=models.PositiveIntegerField(verbose_name='Port speed (Kbps)'),
-        ),
-        migrations.AlterField(
-            model_name='circuittermination',
-            name='pp_info',
-            field=models.CharField(blank=True, max_length=100, verbose_name='Patch panel/port(s)'),
-        ),
-        migrations.AlterField(
-            model_name='circuittermination',
-            name='term_side',
-            field=models.CharField(choices=[('A', 'A'), ('Z', 'Z')], max_length=1, verbose_name='Termination'),
-        ),
-        migrations.AlterField(
-            model_name='circuittermination',
-            name='upstream_speed',
-            field=models.PositiveIntegerField(blank=True, help_text='Upstream speed, if different from port speed', null=True, verbose_name='Upstream speed (Kbps)'),
-        ),
-        migrations.AlterField(
-            model_name='circuittermination',
-            name='xconnect_id',
-            field=models.CharField(blank=True, max_length=50, verbose_name='Cross-connect ID'),
-        ),
-        migrations.AlterField(
-            model_name='provider',
-            name='account',
-            field=models.CharField(blank=True, max_length=30, verbose_name='Account number'),
-        ),
-        migrations.AlterField(
-            model_name='provider',
-            name='admin_contact',
-            field=models.TextField(blank=True, verbose_name='Admin contact'),
-        ),
-        migrations.AlterField(
-            model_name='provider',
-            name='asn',
-            field=dcim.fields.ASNField(blank=True, null=True, verbose_name='ASN'),
-        ),
-        migrations.AlterField(
-            model_name='provider',
-            name='noc_contact',
-            field=models.TextField(blank=True, verbose_name='NOC contact'),
-        ),
-        migrations.AlterField(
-            model_name='provider',
-            name='portal_url',
-            field=models.URLField(blank=True, verbose_name='Portal'),
-        ),
-    ]

netbox/circuits/models.py

@@ -1,8 +1,6 @@
-from __future__ import unicode_literals
-
 from django.contrib.contenttypes.fields import GenericRelation
+from django.core.urlresolvers import reverse
 from django.db import models
-from django.urls import reverse
 from django.utils.encoding import python_2_unicode_compatible
 
 from dcim.fields import ASNField
@@ -10,7 +8,14 @@ from extras.models import CustomFieldModel, CustomFieldValue
 from tenancy.models import Tenant
 from utilities.utils import csv_format
 from utilities.models import CreatedUpdatedModel
-from .constants import *
+
+
+TERM_SIDE_A = 'A'
+TERM_SIDE_Z = 'Z'
+TERM_SIDE_CHOICES = (
+    (TERM_SIDE_A, 'A'),
+    (TERM_SIDE_Z, 'Z'),
+)
 
 
 def humanize_speed(speed):
@@ -45,8 +50,6 @@ class Provider(CreatedUpdatedModel, CustomFieldModel):
     comments = models.TextField(blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
 
-    csv_headers = ['name', 'slug', 'asn', 'account', 'portal_url']
-
     class Meta:
         ordering = ['name']
 
@@ -102,14 +105,12 @@ class Circuit(CreatedUpdatedModel, CustomFieldModel):
     comments = models.TextField(blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
 
-    csv_headers = ['cid', 'provider', 'type', 'tenant', 'install_date', 'commit_rate', 'description']
-
     class Meta:
         ordering = ['provider', 'cid']
         unique_together = ['provider', 'cid']
 
     def __str__(self):
-        return '{} {}'.format(self.provider, self.cid)
+        return u'{} {}'.format(self.provider, self.cid)
 
     def get_absolute_url(self):
         return reverse('circuits:circuit', args=[self.pk])
@@ -149,14 +150,10 @@ class CircuitTermination(models.Model):
     circuit = models.ForeignKey('Circuit', related_name='terminations', on_delete=models.CASCADE)
     term_side = models.CharField(max_length=1, choices=TERM_SIDE_CHOICES, verbose_name='Termination')
     site = models.ForeignKey('dcim.Site', related_name='circuit_terminations', on_delete=models.PROTECT)
-    interface = models.OneToOneField(
+    interface = models.OneToOneField('dcim.Interface', related_name='circuit_termination', blank=True, null=True)
-        'dcim.Interface', related_name='circuit_termination', blank=True, null=True, on_delete=models.PROTECT
-    )
     port_speed = models.PositiveIntegerField(verbose_name='Port speed (Kbps)')
-    upstream_speed = models.PositiveIntegerField(
+    upstream_speed = models.PositiveIntegerField(blank=True, null=True, verbose_name='Upstream speed (Kbps)',
-        blank=True, null=True, verbose_name='Upstream speed (Kbps)',
+                                                 help_text='Upstream speed, if different from port speed')
-        help_text='Upstream speed, if different from port speed'
-    )
     xconnect_id = models.CharField(max_length=50, blank=True, verbose_name='Cross-connect ID')
     pp_info = models.CharField(max_length=100, blank=True, verbose_name='Patch panel/port(s)')
 
@@ -165,7 +162,7 @@ class CircuitTermination(models.Model):
         unique_together = ['circuit', 'term_side']
 
     def __str__(self):
-        return '{} (Side {})'.format(self.circuit, self.get_term_side_display())
+        return u'{} (Side {})'.format(self.circuit, self.get_term_side_display())
 
     def get_peer_termination(self):
         peer_side = 'Z' if self.term_side == 'A' else 'A'

netbox/circuits/signals.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from django.db.models.signals import post_delete, post_save
 from django.dispatch import receiver
 from django.utils import timezone

netbox/circuits/tables.py

@@ -1,9 +1,8 @@
-from __future__ import unicode_literals
-
 import django_tables2 as tables
 from django_tables2.utils import Accessor
 
-from utilities.tables import BaseTable, SearchTable, ToggleColumn
+from utilities.tables import BaseTable, ToggleColumn
+
 from .models import Circuit, CircuitType, Provider
 
 
@@ -20,7 +19,9 @@ CIRCUITTYPE_ACTIONS = """
 
 class ProviderTable(BaseTable):
     pk = ToggleColumn()
-    name = tables.LinkColumn()
+    name = tables.LinkColumn('circuits:provider', args=[Accessor('slug')], verbose_name='Name')
+    asn = tables.Column(verbose_name='ASN')
+    account = tables.Column(verbose_name='Account')
     circuit_count = tables.Column(accessor=Accessor('count_circuits'), verbose_name='Circuits')
 
     class Meta(BaseTable.Meta):
@@ -28,25 +29,17 @@ class ProviderTable(BaseTable):
         fields = ('pk', 'name', 'asn', 'account', 'circuit_count')
 
 
-class ProviderSearchTable(SearchTable):
-    name = tables.LinkColumn()
-
-    class Meta(SearchTable.Meta):
-        model = Provider
-        fields = ('name', 'asn', 'account')
-
-
 #
 # Circuit types
 #
 
 class CircuitTypeTable(BaseTable):
     pk = ToggleColumn()
-    name = tables.LinkColumn()
+    name = tables.LinkColumn(verbose_name='Name')
     circuit_count = tables.Column(verbose_name='Circuits')
-    actions = tables.TemplateColumn(
+    slug = tables.Column(verbose_name='Slug')
-        template_code=CIRCUITTYPE_ACTIONS, attrs={'td': {'class': 'text-right'}}, verbose_name=''
+    actions = tables.TemplateColumn(template_code=CIRCUITTYPE_ACTIONS, attrs={'td': {'class': 'text-right'}},
-    )
+                                    verbose_name='')
 
     class Meta(BaseTable.Meta):
         model = CircuitType
@@ -59,34 +52,16 @@ class CircuitTypeTable(BaseTable):
 
 class CircuitTable(BaseTable):
     pk = ToggleColumn()
-    cid = tables.LinkColumn(verbose_name='ID')
+    cid = tables.LinkColumn('circuits:circuit', args=[Accessor('pk')], verbose_name='ID')
-    provider = tables.LinkColumn('circuits:provider', args=[Accessor('provider.slug')])
+    type = tables.Column(verbose_name='Type')
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
+    provider = tables.LinkColumn('circuits:provider', args=[Accessor('provider.slug')], verbose_name='Provider')
-    a_side = tables.LinkColumn(
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
-        'dcim:site', accessor=Accessor('termination_a.site'), orderable=False,
+    a_side = tables.LinkColumn('dcim:site', accessor=Accessor('termination_a.site'), orderable=False,
-        args=[Accessor('termination_a.site.slug')]
+                               args=[Accessor('termination_a.site.slug')])
-    )
+    z_side = tables.LinkColumn('dcim:site', accessor=Accessor('termination_z.site'), orderable=False,
-    z_side = tables.LinkColumn(
+                               args=[Accessor('termination_z.site.slug')])
-        'dcim:site', accessor=Accessor('termination_z.site'), orderable=False,
+    description = tables.Column(verbose_name='Description')
-        args=[Accessor('termination_z.site.slug')]
-    )
 
     class Meta(BaseTable.Meta):
         model = Circuit
         fields = ('pk', 'cid', 'type', 'provider', 'tenant', 'a_side', 'z_side', 'description')
-
-
-class CircuitSearchTable(SearchTable):
-    cid = tables.LinkColumn(verbose_name='ID')
-    provider = tables.LinkColumn('circuits:provider', args=[Accessor('provider.slug')])
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
-    a_side = tables.LinkColumn(
-        'dcim:site', accessor=Accessor('termination_a.site'), args=[Accessor('termination_a.site.slug')]
-    )
-    z_side = tables.LinkColumn(
-        'dcim:site', accessor=Accessor('termination_z.site'), args=[Accessor('termination_z.site.slug')]
-    )
-
-    class Meta(SearchTable.Meta):
-        model = Circuit
-        fields = ('cid', 'type', 'provider', 'tenant', 'a_side', 'z_side', 'description')

netbox/circuits/tests/test_api.py

@@ -1,331 +0,0 @@
-from __future__ import unicode_literals
-
-from rest_framework import status
-from rest_framework.test import APITestCase
-
-from django.contrib.auth.models import User
-from django.urls import reverse
-
-from dcim.models import Site
-from extras.models import Graph, GRAPH_TYPE_PROVIDER
-from circuits.models import Circuit, CircuitTermination, CircuitType, Provider, TERM_SIDE_A, TERM_SIDE_Z
-from users.models import Token
-from utilities.tests import HttpStatusMixin
-
-
-class ProviderTest(HttpStatusMixin, APITestCase):
-
-    def setUp(self):
-
-        user = User.objects.create(username='testuser', is_superuser=True)
-        token = Token.objects.create(user=user)
-        self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
-
-        self.provider1 = Provider.objects.create(name='Test Provider 1', slug='test-provider-1')
-        self.provider2 = Provider.objects.create(name='Test Provider 2', slug='test-provider-2')
-        self.provider3 = Provider.objects.create(name='Test Provider 3', slug='test-provider-3')
-
-    def test_get_provider(self):
-
-        url = reverse('circuits-api:provider-detail', kwargs={'pk': self.provider1.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['name'], self.provider1.name)
-
-    def test_get_provider_graphs(self):
-
-        self.graph1 = Graph.objects.create(
-            type=GRAPH_TYPE_PROVIDER, name='Test Graph 1',
-            source='http://example.com/graphs.py?provider={{ obj.slug }}&foo=1'
-        )
-        self.graph2 = Graph.objects.create(
-            type=GRAPH_TYPE_PROVIDER, name='Test Graph 2',
-            source='http://example.com/graphs.py?provider={{ obj.slug }}&foo=2'
-        )
-        self.graph3 = Graph.objects.create(
-            type=GRAPH_TYPE_PROVIDER, name='Test Graph 3',
-            source='http://example.com/graphs.py?provider={{ obj.slug }}&foo=3'
-        )
-
-        url = reverse('circuits-api:provider-graphs', kwargs={'pk': self.provider1.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(len(response.data), 3)
-        self.assertEqual(response.data[0]['embed_url'], 'http://example.com/graphs.py?provider=test-provider-1&foo=1')
-
-    def test_list_providers(self):
-
-        url = reverse('circuits-api:provider-list')
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['count'], 3)
-
-    def test_create_provider(self):
-
-        data = {
-            'name': 'Test Provider 4',
-            'slug': 'test-provider-4',
-        }
-
-        url = reverse('circuits-api:provider-list')
-        response = self.client.post(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(Provider.objects.count(), 4)
-        provider4 = Provider.objects.get(pk=response.data['id'])
-        self.assertEqual(provider4.name, data['name'])
-        self.assertEqual(provider4.slug, data['slug'])
-
-    def test_update_provider(self):
-
-        data = {
-            'name': 'Test Provider X',
-            'slug': 'test-provider-x',
-        }
-
-        url = reverse('circuits-api:provider-detail', kwargs={'pk': self.provider1.pk})
-        response = self.client.put(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(Provider.objects.count(), 3)
-        provider1 = Provider.objects.get(pk=response.data['id'])
-        self.assertEqual(provider1.name, data['name'])
-        self.assertEqual(provider1.slug, data['slug'])
-
-    def test_delete_provider(self):
-
-        url = reverse('circuits-api:provider-detail', kwargs={'pk': self.provider1.pk})
-        response = self.client.delete(url, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(Provider.objects.count(), 2)
-
-
-class CircuitTypeTest(HttpStatusMixin, APITestCase):
-
-    def setUp(self):
-
-        user = User.objects.create(username='testuser', is_superuser=True)
-        token = Token.objects.create(user=user)
-        self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
-
-        self.circuittype1 = CircuitType.objects.create(name='Test Circuit Type 1', slug='test-circuit-type-1')
-        self.circuittype2 = CircuitType.objects.create(name='Test Circuit Type 2', slug='test-circuit-type-2')
-        self.circuittype3 = CircuitType.objects.create(name='Test Circuit Type 3', slug='test-circuit-type-3')
-
-    def test_get_circuittype(self):
-
-        url = reverse('circuits-api:circuittype-detail', kwargs={'pk': self.circuittype1.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['name'], self.circuittype1.name)
-
-    def test_list_circuittypes(self):
-
-        url = reverse('circuits-api:circuittype-list')
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['count'], 3)
-
-    def test_create_circuittype(self):
-
-        data = {
-            'name': 'Test Circuit Type 4',
-            'slug': 'test-circuit-type-4',
-        }
-
-        url = reverse('circuits-api:circuittype-list')
-        response = self.client.post(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(CircuitType.objects.count(), 4)
-        circuittype4 = CircuitType.objects.get(pk=response.data['id'])
-        self.assertEqual(circuittype4.name, data['name'])
-        self.assertEqual(circuittype4.slug, data['slug'])
-
-    def test_update_circuittype(self):
-
-        data = {
-            'name': 'Test Circuit Type X',
-            'slug': 'test-circuit-type-x',
-        }
-
-        url = reverse('circuits-api:circuittype-detail', kwargs={'pk': self.circuittype1.pk})
-        response = self.client.put(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(CircuitType.objects.count(), 3)
-        circuittype1 = CircuitType.objects.get(pk=response.data['id'])
-        self.assertEqual(circuittype1.name, data['name'])
-        self.assertEqual(circuittype1.slug, data['slug'])
-
-    def test_delete_circuittype(self):
-
-        url = reverse('circuits-api:circuittype-detail', kwargs={'pk': self.circuittype1.pk})
-        response = self.client.delete(url, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(CircuitType.objects.count(), 2)
-
-
-class CircuitTest(HttpStatusMixin, APITestCase):
-
-    def setUp(self):
-
-        user = User.objects.create(username='testuser', is_superuser=True)
-        token = Token.objects.create(user=user)
-        self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
-
-        self.provider1 = Provider.objects.create(name='Test Provider 1', slug='test-provider-1')
-        self.provider2 = Provider.objects.create(name='Test Provider 2', slug='test-provider-2')
-        self.circuittype1 = CircuitType.objects.create(name='Test Circuit Type 1', slug='test-circuit-type-1')
-        self.circuittype2 = CircuitType.objects.create(name='Test Circuit Type 2', slug='test-circuit-type-2')
-        self.circuit1 = Circuit.objects.create(cid='TEST0001', provider=self.provider1, type=self.circuittype1)
-        self.circuit2 = Circuit.objects.create(cid='TEST0002', provider=self.provider1, type=self.circuittype1)
-        self.circuit3 = Circuit.objects.create(cid='TEST0003', provider=self.provider1, type=self.circuittype1)
-
-    def test_get_circuit(self):
-
-        url = reverse('circuits-api:circuit-detail', kwargs={'pk': self.circuit1.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['cid'], self.circuit1.cid)
-
-    def test_list_circuits(self):
-
-        url = reverse('circuits-api:circuit-list')
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['count'], 3)
-
-    def test_create_circuit(self):
-
-        data = {
-            'cid': 'TEST0004',
-            'provider': self.provider1.pk,
-            'type': self.circuittype1.pk,
-        }
-
-        url = reverse('circuits-api:circuit-list')
-        response = self.client.post(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(Circuit.objects.count(), 4)
-        circuit4 = Circuit.objects.get(pk=response.data['id'])
-        self.assertEqual(circuit4.cid, data['cid'])
-        self.assertEqual(circuit4.provider_id, data['provider'])
-        self.assertEqual(circuit4.type_id, data['type'])
-
-    def test_update_circuit(self):
-
-        data = {
-            'cid': 'TEST000X',
-            'provider': self.provider2.pk,
-            'type': self.circuittype2.pk,
-        }
-
-        url = reverse('circuits-api:circuit-detail', kwargs={'pk': self.circuit1.pk})
-        response = self.client.put(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(Circuit.objects.count(), 3)
-        circuit1 = Circuit.objects.get(pk=response.data['id'])
-        self.assertEqual(circuit1.cid, data['cid'])
-        self.assertEqual(circuit1.provider_id, data['provider'])
-        self.assertEqual(circuit1.type_id, data['type'])
-
-    def test_delete_circuit(self):
-
-        url = reverse('circuits-api:circuit-detail', kwargs={'pk': self.circuit1.pk})
-        response = self.client.delete(url, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(Circuit.objects.count(), 2)
-
-
-class CircuitTerminationTest(HttpStatusMixin, APITestCase):
-
-    def setUp(self):
-
-        user = User.objects.create(username='testuser', is_superuser=True)
-        token = Token.objects.create(user=user)
-        self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
-
-        provider = Provider.objects.create(name='Test Provider', slug='test-provider')
-        circuittype = CircuitType.objects.create(name='Test Circuit Type', slug='test-circuit-type')
-        self.circuit1 = Circuit.objects.create(cid='TEST0001', provider=provider, type=circuittype)
-        self.circuit2 = Circuit.objects.create(cid='TEST0002', provider=provider, type=circuittype)
-        self.circuit3 = Circuit.objects.create(cid='TEST0003', provider=provider, type=circuittype)
-        self.site1 = Site.objects.create(name='Test Site 1', slug='test-site-1')
-        self.site2 = Site.objects.create(name='Test Site 2', slug='test-site-2')
-        self.circuittermination1 = CircuitTermination.objects.create(
-            circuit=self.circuit1, term_side=TERM_SIDE_A, site=self.site1, port_speed=1000000
-        )
-        self.circuittermination2 = CircuitTermination.objects.create(
-            circuit=self.circuit2, term_side=TERM_SIDE_A, site=self.site1, port_speed=1000000
-        )
-        self.circuittermination3 = CircuitTermination.objects.create(
-            circuit=self.circuit3, term_side=TERM_SIDE_A, site=self.site1, port_speed=1000000
-        )
-
-    def test_get_circuittermination(self):
-
-        url = reverse('circuits-api:circuittermination-detail', kwargs={'pk': self.circuittermination1.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['id'], self.circuittermination1.pk)
-
-    def test_list_circuitterminations(self):
-
-        url = reverse('circuits-api:circuittermination-list')
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['count'], 3)
-
-    def test_create_circuittermination(self):
-
-        data = {
-            'circuit': self.circuit1.pk,
-            'term_side': TERM_SIDE_Z,
-            'site': self.site2.pk,
-            'port_speed': 1000000,
-        }
-
-        url = reverse('circuits-api:circuittermination-list')
-        response = self.client.post(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(CircuitTermination.objects.count(), 4)
-        circuittermination4 = CircuitTermination.objects.get(pk=response.data['id'])
-        self.assertEqual(circuittermination4.circuit_id, data['circuit'])
-        self.assertEqual(circuittermination4.term_side, data['term_side'])
-        self.assertEqual(circuittermination4.site_id, data['site'])
-        self.assertEqual(circuittermination4.port_speed, data['port_speed'])
-
-    def test_update_circuittermination(self):
-
-        data = {
-            'circuit': self.circuit1.pk,
-            'term_side': TERM_SIDE_Z,
-            'site': self.site2.pk,
-            'port_speed': 1000000,
-        }
-
-        url = reverse('circuits-api:circuittermination-detail', kwargs={'pk': self.circuittermination1.pk})
-        response = self.client.put(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(CircuitTermination.objects.count(), 3)
-        circuittermination1 = CircuitTermination.objects.get(pk=response.data['id'])
-        self.assertEqual(circuittermination1.circuit_id, data['circuit'])
-        self.assertEqual(circuittermination1.term_side, data['term_side'])
-        self.assertEqual(circuittermination1.site_id, data['site'])
-        self.assertEqual(circuittermination1.port_speed, data['port_speed'])
-
-    def test_delete_circuittermination(self):
-
-        url = reverse('circuits-api:circuittermination-detail', kwargs={'pk': self.circuittermination1.pk})
-        response = self.client.delete(url, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(CircuitTermination.objects.count(), 2)

netbox/circuits/urls.py

@@ -1,42 +1,39 @@
-from __future__ import unicode_literals
-
 from django.conf.urls import url
 
 from . import views
 
 
-app_name = 'circuits'
 urlpatterns = [
 
     # Providers
     url(r'^providers/$', views.ProviderListView.as_view(), name='provider_list'),
-    url(r'^providers/add/$', views.ProviderCreateView.as_view(), name='provider_add'),
+    url(r'^providers/add/$', views.ProviderEditView.as_view(), name='provider_add'),
     url(r'^providers/import/$', views.ProviderBulkImportView.as_view(), name='provider_import'),
     url(r'^providers/edit/$', views.ProviderBulkEditView.as_view(), name='provider_bulk_edit'),
     url(r'^providers/delete/$', views.ProviderBulkDeleteView.as_view(), name='provider_bulk_delete'),
-    url(r'^providers/(?P<slug>[\w-]+)/$', views.ProviderView.as_view(), name='provider'),
+    url(r'^providers/(?P<slug>[\w-]+)/$', views.provider, name='provider'),
     url(r'^providers/(?P<slug>[\w-]+)/edit/$', views.ProviderEditView.as_view(), name='provider_edit'),
     url(r'^providers/(?P<slug>[\w-]+)/delete/$', views.ProviderDeleteView.as_view(), name='provider_delete'),
 
     # Circuit types
     url(r'^circuit-types/$', views.CircuitTypeListView.as_view(), name='circuittype_list'),
-    url(r'^circuit-types/add/$', views.CircuitTypeCreateView.as_view(), name='circuittype_add'),
+    url(r'^circuit-types/add/$', views.CircuitTypeEditView.as_view(), name='circuittype_add'),
     url(r'^circuit-types/delete/$', views.CircuitTypeBulkDeleteView.as_view(), name='circuittype_bulk_delete'),
     url(r'^circuit-types/(?P<slug>[\w-]+)/edit/$', views.CircuitTypeEditView.as_view(), name='circuittype_edit'),
 
     # Circuits
     url(r'^circuits/$', views.CircuitListView.as_view(), name='circuit_list'),
-    url(r'^circuits/add/$', views.CircuitCreateView.as_view(), name='circuit_add'),
+    url(r'^circuits/add/$', views.CircuitEditView.as_view(), name='circuit_add'),
     url(r'^circuits/import/$', views.CircuitBulkImportView.as_view(), name='circuit_import'),
     url(r'^circuits/edit/$', views.CircuitBulkEditView.as_view(), name='circuit_bulk_edit'),
     url(r'^circuits/delete/$', views.CircuitBulkDeleteView.as_view(), name='circuit_bulk_delete'),
-    url(r'^circuits/(?P<pk>\d+)/$', views.CircuitView.as_view(), name='circuit'),
+    url(r'^circuits/(?P<pk>\d+)/$', views.circuit, name='circuit'),
     url(r'^circuits/(?P<pk>\d+)/edit/$', views.CircuitEditView.as_view(), name='circuit_edit'),
     url(r'^circuits/(?P<pk>\d+)/delete/$', views.CircuitDeleteView.as_view(), name='circuit_delete'),
     url(r'^circuits/(?P<pk>\d+)/terminations/swap/$', views.circuit_terminations_swap, name='circuit_terminations_swap'),
 
     # Circuit terminations
-    url(r'^circuits/(?P<circuit>\d+)/terminations/add/$', views.CircuitTerminationCreateView.as_view(), name='circuittermination_add'),
+    url(r'^circuits/(?P<circuit>\d+)/terminations/add/$', views.CircuitTerminationEditView.as_view(), name='circuittermination_add'),
     url(r'^circuit-terminations/(?P<pk>\d+)/edit/$', views.CircuitTerminationEditView.as_view(), name='circuittermination_edit'),
     url(r'^circuit-terminations/(?P<pk>\d+)/delete/$', views.CircuitTerminationDeleteView.as_view(), name='circuittermination_delete'),
 

netbox/circuits/views.py

@@ -1,19 +1,17 @@
-from __future__ import unicode_literals
-
 from django.contrib import messages
 from django.contrib.auth.decorators import permission_required
 from django.contrib.auth.mixins import PermissionRequiredMixin
+from django.core.urlresolvers import reverse
 from django.db import transaction
 from django.db.models import Count
 from django.shortcuts import get_object_or_404, redirect, render
-from django.urls import reverse
-from django.views.generic import View
 
 from extras.models import Graph, GRAPH_TYPE_PROVIDER
 from utilities.forms import ConfirmationForm
 from utilities.views import (
     BulkDeleteView, BulkEditView, BulkImportView, ObjectDeleteView, ObjectEditView, ObjectListView,
 )
+
 from . import filters, forms, tables
 from .models import Circuit, CircuitTermination, CircuitType, Provider, TERM_SIDE_A, TERM_SIDE_Z
 
@@ -30,16 +28,11 @@ class ProviderListView(ObjectListView):
     template_name = 'circuits/provider_list.html'
 
 
-class ProviderView(View):
+def provider(request, slug):
-
-    def get(self, request, slug):
 
     provider = get_object_or_404(Provider, slug=slug)
-        circuits = Circuit.objects.filter(provider=provider).select_related(
+    circuits = Circuit.objects.filter(provider=provider).select_related('type', 'tenant')\
-            'type', 'tenant'
+        .prefetch_related('terminations__site')
-        ).prefetch_related(
-            'terminations__site'
-        )
     show_graphs = Graph.objects.filter(type=GRAPH_TYPE_PROVIDER).exists()
 
     return render(request, 'circuits/provider.html', {
@@ -49,18 +42,14 @@ class ProviderView(View):
     })
 
 
-class ProviderCreateView(PermissionRequiredMixin, ObjectEditView):
+class ProviderEditView(PermissionRequiredMixin, ObjectEditView):
-    permission_required = 'circuits.add_provider'
+    permission_required = 'circuits.change_provider'
     model = Provider
     form_class = forms.ProviderForm
     template_name = 'circuits/provider_edit.html'
     default_return_url = 'circuits:provider_list'
 
 
-class ProviderEditView(ProviderCreateView):
-    permission_required = 'circuits.change_provider'
-
-
 class ProviderDeleteView(PermissionRequiredMixin, ObjectDeleteView):
     permission_required = 'circuits.delete_provider'
     model = Provider
@@ -69,8 +58,9 @@ class ProviderDeleteView(PermissionRequiredMixin, ObjectDeleteView):
 
 class ProviderBulkImportView(PermissionRequiredMixin, BulkImportView):
     permission_required = 'circuits.add_provider'
-    model_form = forms.ProviderCSVForm
+    form = forms.ProviderImportForm
     table = tables.ProviderTable
+    template_name = 'circuits/provider_import.html'
     default_return_url = 'circuits:provider_list'
 
 
@@ -100,19 +90,15 @@ class CircuitTypeListView(ObjectListView):
     template_name = 'circuits/circuittype_list.html'
 
 
-class CircuitTypeCreateView(PermissionRequiredMixin, ObjectEditView):
+class CircuitTypeEditView(PermissionRequiredMixin, ObjectEditView):
-    permission_required = 'circuits.add_circuittype'
+    permission_required = 'circuits.change_circuittype'
     model = CircuitType
     form_class = forms.CircuitTypeForm
 
-    def get_return_url(self, request, obj):
+    def get_return_url(self, obj):
         return reverse('circuits:circuittype_list')
 
 
-class CircuitTypeEditView(CircuitTypeCreateView):
-    permission_required = 'circuits.change_circuittype'
-
-
 class CircuitTypeBulkDeleteView(PermissionRequiredMixin, BulkDeleteView):
     permission_required = 'circuits.delete_circuittype'
     cls = CircuitType
@@ -131,9 +117,7 @@ class CircuitListView(ObjectListView):
     template_name = 'circuits/circuit_list.html'
 
 
-class CircuitView(View):
+def circuit(request, pk):
-
-    def get(self, request, pk):
 
     circuit = get_object_or_404(Circuit.objects.select_related('provider', 'type', 'tenant__group'), pk=pk)
     termination_a = CircuitTermination.objects.select_related(
@@ -154,18 +138,15 @@ class CircuitView(View):
     })
 
 
-class CircuitCreateView(PermissionRequiredMixin, ObjectEditView):
+class CircuitEditView(PermissionRequiredMixin, ObjectEditView):
-    permission_required = 'circuits.add_circuit'
+    permission_required = 'circuits.change_circuit'
     model = Circuit
     form_class = forms.CircuitForm
+    fields_initial = ['provider']
     template_name = 'circuits/circuit_edit.html'
     default_return_url = 'circuits:circuit_list'
 
 
-class CircuitEditView(CircuitCreateView):
-    permission_required = 'circuits.change_circuit'
-
-
 class CircuitDeleteView(PermissionRequiredMixin, ObjectDeleteView):
     permission_required = 'circuits.delete_circuit'
     model = Circuit
@@ -174,8 +155,9 @@ class CircuitDeleteView(PermissionRequiredMixin, ObjectDeleteView):
 
 class CircuitBulkImportView(PermissionRequiredMixin, BulkImportView):
     permission_required = 'circuits.add_circuit'
-    model_form = forms.CircuitCSVForm
+    form = forms.CircuitImportForm
     table = tables.CircuitTable
+    template_name = 'circuits/circuit_import.html'
     default_return_url = 'circuits:circuit_list'
 
 
@@ -244,10 +226,11 @@ def circuit_terminations_swap(request, pk):
 # Circuit terminations
 #
 
-class CircuitTerminationCreateView(PermissionRequiredMixin, ObjectEditView):
+class CircuitTerminationEditView(PermissionRequiredMixin, ObjectEditView):
-    permission_required = 'circuits.add_circuittermination'
+    permission_required = 'circuits.change_circuittermination'
     model = CircuitTermination
     form_class = forms.CircuitTerminationForm
+    fields_initial = ['term_side']
     template_name = 'circuits/circuittermination_edit.html'
 
     def alter_obj(self, obj, request, url_args, url_kwargs):
@@ -255,14 +238,10 @@ class CircuitTerminationCreateView(PermissionRequiredMixin, ObjectEditView):
             obj.circuit = get_object_or_404(Circuit, pk=url_kwargs['circuit'])
         return obj
 
-    def get_return_url(self, request, obj):
+    def get_return_url(self, obj):
         return obj.circuit.get_absolute_url()
 
 
-class CircuitTerminationEditView(CircuitTerminationCreateView):
-    permission_required = 'circuits.change_circuittermination'
-
-
 class CircuitTerminationDeleteView(PermissionRequiredMixin, ObjectDeleteView):
     permission_required = 'circuits.delete_circuittermination'
     model = CircuitTermination

netbox/dcim/admin.py

@@ -0,0 +1,212 @@
+from django.contrib import admin
+from django.db.models import Count
+
+from mptt.admin import MPTTModelAdmin
+
+from .models import (
+    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceBay,
+    DeviceBayTemplate, DeviceRole, DeviceType, Interface, InterfaceTemplate, Manufacturer, Module, Platform,
+    PowerOutlet, PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack, RackGroup, RackReservation, RackRole, Region,
+    Site,
+)
+
+
+@admin.register(Region)
+class RegionAdmin(MPTTModelAdmin):
+    list_display = ['name', 'parent', 'slug']
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+
+
+@admin.register(Site)
+class SiteAdmin(admin.ModelAdmin):
+    list_display = ['name', 'slug', 'facility', 'asn']
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+
+
+@admin.register(RackGroup)
+class RackGroupAdmin(admin.ModelAdmin):
+    list_display = ['name', 'slug', 'site']
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+
+
+@admin.register(RackRole)
+class RackRoleAdmin(admin.ModelAdmin):
+    list_display = ['name', 'slug', 'color']
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+
+
+@admin.register(Rack)
+class RackAdmin(admin.ModelAdmin):
+    list_display = ['name', 'facility_id', 'site', 'group', 'tenant', 'role', 'type', 'width', 'u_height']
+
+
+@admin.register(RackReservation)
+class RackRackReservationAdmin(admin.ModelAdmin):
+    list_display = ['rack', 'units', 'description', 'user', 'created']
+
+
+#
+# Device types
+#
+
+@admin.register(Manufacturer)
+class ManufacturerAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+    list_display = ['name', 'slug']
+
+
+class ConsolePortTemplateAdmin(admin.TabularInline):
+    model = ConsolePortTemplate
+
+
+class ConsoleServerPortTemplateAdmin(admin.TabularInline):
+    model = ConsoleServerPortTemplate
+
+
+class PowerPortTemplateAdmin(admin.TabularInline):
+    model = PowerPortTemplate
+
+
+class PowerOutletTemplateAdmin(admin.TabularInline):
+    model = PowerOutletTemplate
+
+
+class InterfaceTemplateAdmin(admin.TabularInline):
+    model = InterfaceTemplate
+
+
+class DeviceBayTemplateAdmin(admin.TabularInline):
+    model = DeviceBayTemplate
+
+
+@admin.register(DeviceType)
+class DeviceTypeAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['model'],
+    }
+    inlines = [
+        ConsolePortTemplateAdmin,
+        ConsoleServerPortTemplateAdmin,
+        PowerPortTemplateAdmin,
+        PowerOutletTemplateAdmin,
+        InterfaceTemplateAdmin,
+        DeviceBayTemplateAdmin,
+    ]
+    list_display = ['model', 'manufacturer', 'slug', 'part_number', 'u_height', 'console_ports', 'console_server_ports',
+                    'power_ports', 'power_outlets', 'interfaces', 'device_bays']
+    list_filter = ['manufacturer']
+
+    def get_queryset(self, request):
+        return DeviceType.objects.annotate(
+            console_port_count=Count('console_port_templates', distinct=True),
+            cs_port_count=Count('cs_port_templates', distinct=True),
+            power_port_count=Count('power_port_templates', distinct=True),
+            power_outlet_count=Count('power_outlet_templates', distinct=True),
+            interface_count=Count('interface_templates', distinct=True),
+            devicebay_count=Count('device_bay_templates', distinct=True),
+        )
+
+    def console_ports(self, instance):
+        return instance.console_port_count
+
+    def console_server_ports(self, instance):
+        return instance.cs_port_count
+
+    def power_ports(self, instance):
+        return instance.power_port_count
+
+    def power_outlets(self, instance):
+        return instance.power_outlet_count
+
+    def interfaces(self, instance):
+        return instance.interface_count
+
+    def device_bays(self, instance):
+        return instance.devicebay_count
+
+
+#
+# Devices
+#
+
+@admin.register(DeviceRole)
+class DeviceRoleAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+    list_display = ['name', 'slug', 'color']
+
+
+@admin.register(Platform)
+class PlatformAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+    list_display = ['name', 'rpc_client']
+
+
+class ConsolePortAdmin(admin.TabularInline):
+    model = ConsolePort
+    readonly_fields = ['cs_port']
+
+
+class ConsoleServerPortAdmin(admin.TabularInline):
+    model = ConsoleServerPort
+
+
+class PowerPortAdmin(admin.TabularInline):
+    model = PowerPort
+    readonly_fields = ['power_outlet']
+
+
+class PowerOutletAdmin(admin.TabularInline):
+    model = PowerOutlet
+
+
+class InterfaceAdmin(admin.TabularInline):
+    model = Interface
+
+
+class DeviceBayAdmin(admin.TabularInline):
+    model = DeviceBay
+    fk_name = 'device'
+    readonly_fields = ['installed_device']
+
+
+class ModuleAdmin(admin.TabularInline):
+    model = Module
+    readonly_fields = ['parent', 'discovered']
+
+
+@admin.register(Device)
+class DeviceAdmin(admin.ModelAdmin):
+    inlines = [
+        ConsolePortAdmin,
+        ConsoleServerPortAdmin,
+        PowerPortAdmin,
+        PowerOutletAdmin,
+        InterfaceAdmin,
+        DeviceBayAdmin,
+        ModuleAdmin,
+    ]
+    list_display = ['display_name', 'device_type_full_name', 'device_role', 'primary_ip', 'rack', 'position', 'asset_tag',
+                    'serial']
+    list_filter = ['device_role']
+
+    def get_queryset(self, request):
+        qs = super(DeviceAdmin, self).get_queryset(request)
+        return qs.select_related('device_type__manufacturer', 'device_role', 'primary_ip4', 'primary_ip6', 'rack')
+
+    def device_type_full_name(self, obj):
+        return obj.device_type.full_name
+    device_type_full_name.short_description = 'Device type'

netbox/dcim/api/exceptions.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from rest_framework.exceptions import APIException
 
 

netbox/dcim/api/serializers.py

@@ -1,44 +1,28 @@
-from __future__ import unicode_literals
-from collections import OrderedDict
-
 from rest_framework import serializers
-from rest_framework.validators import UniqueTogetherValidator
 
 from ipam.models import IPAddress
-from circuits.models import Circuit, CircuitTermination
 from dcim.models import (
-    CONNECTION_STATUS_CHOICES, ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device,
+    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceBay, DeviceType,
-    DeviceBay, DeviceBayTemplate, DeviceType, DeviceRole, IFACE_FF_CHOICES, IFACE_ORDERING_CHOICES, Interface,
+    DeviceRole, Interface, InterfaceConnection, InterfaceTemplate, Manufacturer, Module, Platform, PowerOutlet,
-    InterfaceConnection, InterfaceTemplate, Manufacturer, InventoryItem, Platform, PowerOutlet, PowerOutletTemplate,
+    PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack, RackGroup, RackReservation, RackRole, RACK_FACE_FRONT,
-    PowerPort, PowerPortTemplate, Rack, RackGroup, RackReservation, RackRole, RACK_FACE_CHOICES, RACK_TYPE_CHOICES,
+    RACK_FACE_REAR, Region, Site, SUBDEVICE_ROLE_CHILD, SUBDEVICE_ROLE_PARENT,
-    RACK_WIDTH_CHOICES, Region, Site, STATUS_CHOICES, SUBDEVICE_ROLE_CHOICES,
 )
-from extras.api.customfields import CustomFieldModelSerializer
+from extras.api.serializers import CustomFieldSerializer
-from tenancy.api.serializers import NestedTenantSerializer
+from tenancy.api.serializers import TenantNestedSerializer
-from utilities.api import ChoiceFieldSerializer, ModelValidationMixin
 
 
 #
 # Regions
 #
 
-class NestedRegionSerializer(serializers.ModelSerializer):
+class RegionNestedSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:region-detail')
 
     class Meta:
         model = Region
-        fields = ['id', 'url', 'name', 'slug']
+        fields = ['id', 'name', 'slug']
 
 
 class RegionSerializer(serializers.ModelSerializer):
-    parent = NestedRegionSerializer()
-
-    class Meta:
-        model = Region
-        fields = ['id', 'name', 'slug', 'parent']
-
-
-class WritableRegionSerializer(ModelValidationMixin, serializers.ModelSerializer):
 
     class Meta:
         model = Region
@@ -49,35 +33,21 @@ class WritableRegionSerializer(ModelValidationMixin, serializers.ModelSerializer
 # Sites
 #
 
-class SiteSerializer(CustomFieldModelSerializer):
+class SiteSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    region = NestedRegionSerializer()
+    region = RegionNestedSerializer()
-    tenant = NestedTenantSerializer()
+    tenant = TenantNestedSerializer()
 
     class Meta:
         model = Site
-        fields = [
+        fields = ['id', 'name', 'slug', 'region', 'tenant', 'facility', 'asn', 'physical_address', 'shipping_address',
-            'id', 'name', 'slug', 'region', 'tenant', 'facility', 'asn', 'physical_address', 'shipping_address',
                   'contact_name', 'contact_phone', 'contact_email', 'comments', 'custom_fields', 'count_prefixes',
-            'count_vlans', 'count_racks', 'count_devices', 'count_circuits',
+                  'count_vlans', 'count_racks', 'count_devices', 'count_circuits']
-        ]
 
 
-class NestedSiteSerializer(serializers.ModelSerializer):
+class SiteNestedSerializer(SiteSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:site-detail')
 
-    class Meta:
+    class Meta(SiteSerializer.Meta):
-        model = Site
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
-
-
-class WritableSiteSerializer(CustomFieldModelSerializer):
-
-    class Meta:
-        model = Site
-        fields = [
-            'id', 'name', 'slug', 'region', 'tenant', 'facility', 'asn', 'physical_address', 'shipping_address',
-            'contact_name', 'contact_phone', 'contact_email', 'comments', 'custom_fields',
-        ]
 
 
 #
@@ -85,123 +55,85 @@ class WritableSiteSerializer(CustomFieldModelSerializer):
 #
 
 class RackGroupSerializer(serializers.ModelSerializer):
-    site = NestedSiteSerializer()
+    site = SiteNestedSerializer()
 
     class Meta:
         model = RackGroup
         fields = ['id', 'name', 'slug', 'site']
 
 
-class NestedRackGroupSerializer(serializers.ModelSerializer):
+class RackGroupNestedSerializer(RackGroupSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:rackgroup-detail')
 
-    class Meta:
+    class Meta(SiteSerializer.Meta):
-        model = RackGroup
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
-
-
-class WritableRackGroupSerializer(ModelValidationMixin, serializers.ModelSerializer):
-
-    class Meta:
-        model = RackGroup
-        fields = ['id', 'name', 'slug', 'site']
 
 
 #
 # Rack roles
 #
 
-class RackRoleSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class RackRoleSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = RackRole
         fields = ['id', 'name', 'slug', 'color']
 
 
-class NestedRackRoleSerializer(serializers.ModelSerializer):
+class RackRoleNestedSerializer(RackRoleSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:rackrole-detail')
 
-    class Meta:
+    class Meta(RackRoleSerializer.Meta):
-        model = RackRole
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
 
 
 #
 # Racks
 #
 
-class RackSerializer(CustomFieldModelSerializer):
+class RackReservationNestedSerializer(serializers.ModelSerializer):
-    site = NestedSiteSerializer()
+
-    group = NestedRackGroupSerializer()
+    class Meta:
-    tenant = NestedTenantSerializer()
+        model = RackReservation
-    role = NestedRackRoleSerializer()
+        fields = ['id', 'units', 'created', 'user', 'description']
-    type = ChoiceFieldSerializer(choices=RACK_TYPE_CHOICES)
+
-    width = ChoiceFieldSerializer(choices=RACK_WIDTH_CHOICES)
+
+class RackSerializer(CustomFieldSerializer, serializers.ModelSerializer):
+    site = SiteNestedSerializer()
+    group = RackGroupNestedSerializer()
+    tenant = TenantNestedSerializer()
+    role = RackRoleNestedSerializer()
 
     class Meta:
         model = Rack
-        fields = [
+        fields = ['id', 'name', 'facility_id', 'display_name', 'site', 'group', 'tenant', 'role', 'type', 'width',
-            'id', 'name', 'facility_id', 'display_name', 'site', 'group', 'tenant', 'role', 'type', 'width', 'u_height',
+                  'u_height', 'desc_units', 'comments', 'custom_fields']
-            'desc_units', 'comments', 'custom_fields',
-        ]
 
 
-class NestedRackSerializer(serializers.ModelSerializer):
+class RackNestedSerializer(RackSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:rack-detail')
 
-    class Meta:
+    class Meta(RackSerializer.Meta):
-        model = Rack
+        fields = ['id', 'name', 'facility_id', 'display_name']
-        fields = ['id', 'url', 'name', 'display_name']
 
 
-class WritableRackSerializer(CustomFieldModelSerializer):
+class RackDetailSerializer(RackSerializer):
+    front_units = serializers.SerializerMethodField()
+    rear_units = serializers.SerializerMethodField()
+    reservations = RackReservationNestedSerializer(many=True)
 
-    class Meta:
+    class Meta(RackSerializer.Meta):
-        model = Rack
+        fields = ['id', 'name', 'facility_id', 'display_name', 'site', 'group', 'tenant', 'role', 'type', 'width',
-        fields = [
+                  'u_height', 'desc_units', 'reservations', 'comments', 'custom_fields', 'front_units', 'rear_units']
-            'id', 'name', 'facility_id', 'site', 'group', 'tenant', 'role', 'type', 'width', 'u_height', 'desc_units',
-            'comments', 'custom_fields',
-        ]
-        # Omit the UniqueTogetherValidator that would be automatically added to validate (site, facility_id). This
-        # prevents facility_id from being interpreted as a required field.
-        validators = [
-            UniqueTogetherValidator(queryset=Rack.objects.all(), fields=('site', 'name'))
-        ]
 
-    def validate(self, data):
+    def get_front_units(self, obj):
+        units = obj.get_rack_units(face=RACK_FACE_FRONT)
+        for u in units:
+            u['device'] = DeviceNestedSerializer(u['device']).data if u['device'] else None
+        return units
 
-        # Validate uniqueness of (site, facility_id) since we omitted the automatically-created validator from Meta.
+    def get_rear_units(self, obj):
-        if data.get('facility_id', None):
+        units = obj.get_rack_units(face=RACK_FACE_REAR)
-            validator = UniqueTogetherValidator(queryset=Rack.objects.all(), fields=('site', 'facility_id'))
+        for u in units:
-            validator.set_context(self)
+            u['device'] = DeviceNestedSerializer(u['device']).data if u['device'] else None
-            validator(data)
+        return units
-
-        # Enforce model validation
-        super(WritableRackSerializer, self).validate(data)
-
-        return data
-
-
-#
-# Rack units
-#
-
-class NestedDeviceSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:device-detail')
-
-    class Meta:
-        model = Device
-        fields = ['id', 'url', 'name', 'display_name']
-
-
-class RackUnitSerializer(serializers.Serializer):
-    """
-    A rack unit is an abstraction formed by the set (rack, position, face); it does not exist as a row in the database.
-    """
-    id = serializers.IntegerField(read_only=True)
-    name = serializers.CharField(read_only=True)
-    face = serializers.IntegerField(read_only=True)
-    device = NestedDeviceSerializer(read_only=True)
 
 
 #
@@ -209,255 +141,164 @@ class RackUnitSerializer(serializers.Serializer):
 #
 
 class RackReservationSerializer(serializers.ModelSerializer):
-    rack = NestedRackSerializer()
+    rack = RackNestedSerializer()
 
     class Meta:
         model = RackReservation
         fields = ['id', 'rack', 'units', 'created', 'user', 'description']
 
 
-class WritableRackReservationSerializer(ModelValidationMixin, serializers.ModelSerializer):
-
-    class Meta:
-        model = RackReservation
-        fields = ['id', 'rack', 'units', 'description']
-
-
 #
 # Manufacturers
 #
 
-class ManufacturerSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class ManufacturerSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Manufacturer
         fields = ['id', 'name', 'slug']
 
 
-class NestedManufacturerSerializer(serializers.ModelSerializer):
+class ManufacturerNestedSerializer(ManufacturerSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:manufacturer-detail')
 
-    class Meta:
+    class Meta(ManufacturerSerializer.Meta):
-        model = Manufacturer
+        pass
-        fields = ['id', 'url', 'name', 'slug']
 
 
 #
 # Device types
 #
 
-class DeviceTypeSerializer(CustomFieldModelSerializer):
+class DeviceTypeSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    manufacturer = NestedManufacturerSerializer()
+    manufacturer = ManufacturerNestedSerializer()
-    interface_ordering = ChoiceFieldSerializer(choices=IFACE_ORDERING_CHOICES)
+    subdevice_role = serializers.SerializerMethodField()
-    subdevice_role = ChoiceFieldSerializer(choices=SUBDEVICE_ROLE_CHOICES)
     instance_count = serializers.IntegerField(source='instances.count', read_only=True)
 
     class Meta:
         model = DeviceType
-        fields = [
+        fields = ['id', 'manufacturer', 'model', 'slug', 'part_number', 'u_height', 'is_full_depth',
-            'id', 'manufacturer', 'model', 'slug', 'part_number', 'u_height', 'is_full_depth', 'interface_ordering',
+                  'interface_ordering', 'is_console_server', 'is_pdu', 'is_network_device', 'subdevice_role',
-            'is_console_server', 'is_pdu', 'is_network_device', 'subdevice_role', 'comments', 'custom_fields',
+                  'comments', 'custom_fields', 'instance_count']
-            'instance_count',
+
-        ]
+    def get_subdevice_role(self, obj):
+        return {
+            SUBDEVICE_ROLE_PARENT: 'parent',
+            SUBDEVICE_ROLE_CHILD: 'child',
+            None: None,
+        }[obj.subdevice_role]
 
 
-class NestedDeviceTypeSerializer(serializers.ModelSerializer):
+class DeviceTypeNestedSerializer(DeviceTypeSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:devicetype-detail')
-    manufacturer = NestedManufacturerSerializer()
 
-    class Meta:
+    class Meta(DeviceTypeSerializer.Meta):
-        model = DeviceType
+        fields = ['id', 'manufacturer', 'model', 'slug']
-        fields = ['id', 'url', 'manufacturer', 'model', 'slug']
 
 
-class WritableDeviceTypeSerializer(CustomFieldModelSerializer):
+class ConsolePortTemplateNestedSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = DeviceType
-        fields = [
-            'id', 'manufacturer', 'model', 'slug', 'part_number', 'u_height', 'is_full_depth', 'interface_ordering',
-            'is_console_server', 'is_pdu', 'is_network_device', 'subdevice_role', 'comments', 'custom_fields',
-        ]
-
-
-#
-# Console port templates
-#
-
-class ConsolePortTemplateSerializer(serializers.ModelSerializer):
-    device_type = NestedDeviceTypeSerializer()
 
     class Meta:
         model = ConsolePortTemplate
-        fields = ['id', 'device_type', 'name']
+        fields = ['id', 'name']
 
 
-class WritableConsolePortTemplateSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class ConsoleServerPortTemplateNestedSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = ConsolePortTemplate
-        fields = ['id', 'device_type', 'name']
-
-
-#
-# Console server port templates
-#
-
-class ConsoleServerPortTemplateSerializer(serializers.ModelSerializer):
-    device_type = NestedDeviceTypeSerializer()
 
     class Meta:
         model = ConsoleServerPortTemplate
-        fields = ['id', 'device_type', 'name']
+        fields = ['id', 'name']
 
 
-class WritableConsoleServerPortTemplateSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class PowerPortTemplateNestedSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = ConsoleServerPortTemplate
-        fields = ['id', 'device_type', 'name']
-
-
-#
-# Power port templates
-#
-
-class PowerPortTemplateSerializer(serializers.ModelSerializer):
-    device_type = NestedDeviceTypeSerializer()
 
     class Meta:
         model = PowerPortTemplate
-        fields = ['id', 'device_type', 'name']
+        fields = ['id', 'name']
 
 
-class WritablePowerPortTemplateSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class PowerOutletTemplateNestedSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = PowerPortTemplate
-        fields = ['id', 'device_type', 'name']
-
-
-#
-# Power outlet templates
-#
-
-class PowerOutletTemplateSerializer(serializers.ModelSerializer):
-    device_type = NestedDeviceTypeSerializer()
 
     class Meta:
         model = PowerOutletTemplate
-        fields = ['id', 'device_type', 'name']
+        fields = ['id', 'name']
 
 
-class WritablePowerOutletTemplateSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class InterfaceTemplateNestedSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = PowerOutletTemplate
-        fields = ['id', 'device_type', 'name']
-
-
-#
-# Interface templates
-#
-
-class InterfaceTemplateSerializer(serializers.ModelSerializer):
-    device_type = NestedDeviceTypeSerializer()
-    form_factor = ChoiceFieldSerializer(choices=IFACE_FF_CHOICES)
 
     class Meta:
         model = InterfaceTemplate
-        fields = ['id', 'device_type', 'name', 'form_factor', 'mgmt_only']
+        fields = ['id', 'name', 'form_factor', 'mgmt_only']
 
 
-class WritableInterfaceTemplateSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class DeviceTypeDetailSerializer(DeviceTypeSerializer):
+    console_port_templates = ConsolePortTemplateNestedSerializer(many=True, read_only=True)
+    cs_port_templates = ConsoleServerPortTemplateNestedSerializer(many=True, read_only=True)
+    power_port_templates = PowerPortTemplateNestedSerializer(many=True, read_only=True)
+    power_outlet_templates = PowerPortTemplateNestedSerializer(many=True, read_only=True)
+    interface_templates = InterfaceTemplateNestedSerializer(many=True, read_only=True)
 
-    class Meta:
+    class Meta(DeviceTypeSerializer.Meta):
-        model = InterfaceTemplate
+        fields = ['id', 'manufacturer', 'model', 'slug', 'part_number', 'u_height', 'is_full_depth',
-        fields = ['id', 'device_type', 'name', 'form_factor', 'mgmt_only']
+                  'interface_ordering', 'is_console_server', 'is_pdu', 'is_network_device', 'subdevice_role',
-
+                  'comments', 'custom_fields', 'console_port_templates', 'cs_port_templates', 'power_port_templates',
-
+                  'power_outlet_templates', 'interface_templates']
-#
-# Device bay templates
-#
-
-class DeviceBayTemplateSerializer(serializers.ModelSerializer):
-    device_type = NestedDeviceTypeSerializer()
-
-    class Meta:
-        model = DeviceBayTemplate
-        fields = ['id', 'device_type', 'name']
-
-
-class WritableDeviceBayTemplateSerializer(ModelValidationMixin, serializers.ModelSerializer):
-
-    class Meta:
-        model = DeviceBayTemplate
-        fields = ['id', 'device_type', 'name']
 
 
 #
 # Device roles
 #
 
-class DeviceRoleSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class DeviceRoleSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = DeviceRole
         fields = ['id', 'name', 'slug', 'color']
 
 
-class NestedDeviceRoleSerializer(serializers.ModelSerializer):
+class DeviceRoleNestedSerializer(DeviceRoleSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:devicerole-detail')
 
-    class Meta:
+    class Meta(DeviceRoleSerializer.Meta):
-        model = DeviceRole
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
 
 
 #
 # Platforms
 #
 
-class PlatformSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class PlatformSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Platform
         fields = ['id', 'name', 'slug', 'rpc_client']
 
 
-class NestedPlatformSerializer(serializers.ModelSerializer):
+class PlatformNestedSerializer(PlatformSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:platform-detail')
 
-    class Meta:
+    class Meta(PlatformSerializer.Meta):
-        model = Platform
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
 
 
 #
 # Devices
 #
 
-# Cannot import ipam.api.NestedIPAddressSerializer due to circular dependency
+# Cannot import ipam.api.IPAddressNestedSerializer due to circular dependency
-class DeviceIPAddressSerializer(serializers.ModelSerializer):
+class DeviceIPAddressNestedSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:ipaddress-detail')
 
     class Meta:
         model = IPAddress
-        fields = ['id', 'url', 'family', 'address']
+        fields = ['id', 'family', 'address']
 
 
-class DeviceSerializer(CustomFieldModelSerializer):
+class DeviceSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    device_type = NestedDeviceTypeSerializer()
+    device_type = DeviceTypeNestedSerializer()
-    device_role = NestedDeviceRoleSerializer()
+    device_role = DeviceRoleNestedSerializer()
-    tenant = NestedTenantSerializer()
+    tenant = TenantNestedSerializer()
-    platform = NestedPlatformSerializer()
+    platform = PlatformNestedSerializer()
-    site = NestedSiteSerializer()
+    site = SiteNestedSerializer()
-    rack = NestedRackSerializer()
+    rack = RackNestedSerializer()
-    face = ChoiceFieldSerializer(choices=RACK_FACE_CHOICES)
+    primary_ip = DeviceIPAddressNestedSerializer()
-    status = ChoiceFieldSerializer(choices=STATUS_CHOICES)
+    primary_ip4 = DeviceIPAddressNestedSerializer()
-    primary_ip = DeviceIPAddressSerializer()
+    primary_ip6 = DeviceIPAddressNestedSerializer()
-    primary_ip4 = DeviceIPAddressSerializer()
-    primary_ip6 = DeviceIPAddressSerializer()
     parent_device = serializers.SerializerMethodField()
 
     class Meta:
@@ -483,28 +324,11 @@ class DeviceSerializer(CustomFieldModelSerializer):
         }
 
 
-class WritableDeviceSerializer(CustomFieldModelSerializer):
+class DeviceNestedSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Device
-        fields = [
+        fields = ['id', 'name', 'display_name']
-            'id', 'name', 'device_type', 'device_role', 'tenant', 'platform', 'serial', 'asset_tag', 'site', 'rack',
-            'position', 'face', 'status', 'primary_ip4', 'primary_ip6', 'comments', 'custom_fields',
-        ]
-        validators = []
-
-    def validate(self, data):
-
-        # Validate uniqueness of (rack, position, face) since we omitted the automatically-created validator from Meta.
-        if data.get('rack') and data.get('position') and data.get('face'):
-            validator = UniqueTogetherValidator(queryset=Device.objects.all(), fields=('rack', 'position', 'face'))
-            validator.set_context(self)
-            validator(data)
-
-        # Enforce model validation
-        super(WritableDeviceSerializer, self).validate(data)
-
-        return data
 
 
 #
@@ -512,18 +336,16 @@ class WritableDeviceSerializer(CustomFieldModelSerializer):
 #
 
 class ConsoleServerPortSerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
 
     class Meta:
         model = ConsoleServerPort
         fields = ['id', 'device', 'name', 'connected_console']
-        read_only_fields = ['connected_console']
 
 
-class WritableConsoleServerPortSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class ConsoleServerPortNestedSerializer(ConsoleServerPortSerializer):
 
-    class Meta:
+    class Meta(ConsoleServerPortSerializer.Meta):
-        model = ConsoleServerPort
         fields = ['id', 'device', 'name']
 
 
@@ -532,19 +354,18 @@ class WritableConsoleServerPortSerializer(ModelValidationMixin, serializers.Mode
 #
 
 class ConsolePortSerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
-    cs_port = ConsoleServerPortSerializer()
+    cs_port = ConsoleServerPortNestedSerializer()
 
     class Meta:
         model = ConsolePort
         fields = ['id', 'device', 'name', 'cs_port', 'connection_status']
 
 
-class WritableConsolePortSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class ConsolePortNestedSerializer(ConsolePortSerializer):
 
-    class Meta:
+    class Meta(ConsolePortSerializer.Meta):
-        model = ConsolePort
+        fields = ['id', 'device', 'name']
-        fields = ['id', 'device', 'name', 'cs_port', 'connection_status']
 
 
 #
@@ -552,18 +373,16 @@ class WritableConsolePortSerializer(ModelValidationMixin, serializers.ModelSeria
 #
 
 class PowerOutletSerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
 
     class Meta:
         model = PowerOutlet
         fields = ['id', 'device', 'name', 'connected_port']
-        read_only_fields = ['connected_port']
 
 
-class WritablePowerOutletSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class PowerOutletNestedSerializer(PowerOutletSerializer):
 
-    class Meta:
+    class Meta(PowerOutletSerializer.Meta):
-        model = PowerOutlet
         fields = ['id', 'device', 'name']
 
 
@@ -572,108 +391,58 @@ class WritablePowerOutletSerializer(ModelValidationMixin, serializers.ModelSeria
 #
 
 class PowerPortSerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
-    power_outlet = PowerOutletSerializer()
+    power_outlet = PowerOutletNestedSerializer()
 
     class Meta:
         model = PowerPort
         fields = ['id', 'device', 'name', 'power_outlet', 'connection_status']
 
 
-class WritablePowerPortSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class PowerPortNestedSerializer(PowerPortSerializer):
 
-    class Meta:
+    class Meta(PowerPortSerializer.Meta):
-        model = PowerPort
+        fields = ['id', 'device', 'name']
-        fields = ['id', 'device', 'name', 'power_outlet', 'connection_status']
 
 
 #
 # Interfaces
 #
 
-class NestedInterfaceSerializer(serializers.ModelSerializer):
+class LAGInterfaceNestedSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:interface-detail')
+    form_factor = serializers.ReadOnlyField(source='get_form_factor_display')
 
     class Meta:
         model = Interface
-        fields = ['id', 'url', 'name']
+        fields = ['id', 'name', 'form_factor']
-
-
-class InterfaceNestedCircuitSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='circuits-api:circuit-detail')
-
-    class Meta:
-        model = Circuit
-        fields = ['id', 'url', 'cid']
-
-
-class InterfaceCircuitTerminationSerializer(serializers.ModelSerializer):
-    circuit = InterfaceNestedCircuitSerializer()
-
-    class Meta:
-        model = CircuitTermination
-        fields = [
-            'id', 'circuit', 'term_side', 'port_speed', 'upstream_speed', 'xconnect_id', 'pp_info',
-        ]
 
 
 class InterfaceSerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
-    form_factor = ChoiceFieldSerializer(choices=IFACE_FF_CHOICES)
+    form_factor = serializers.ReadOnlyField(source='get_form_factor_display')
-    lag = NestedInterfaceSerializer()
+    lag = LAGInterfaceNestedSerializer()
-    is_connected = serializers.SerializerMethodField(read_only=True)
-    interface_connection = serializers.SerializerMethodField(read_only=True)
-    circuit_termination = InterfaceCircuitTerminationSerializer()
 
     class Meta:
         model = Interface
         fields = [
-            'id', 'device', 'name', 'form_factor', 'enabled', 'lag', 'mtu', 'mac_address', 'mgmt_only', 'description',
+            'id', 'device', 'name', 'form_factor', 'lag', 'mac_address', 'mgmt_only', 'description', 'is_connected',
-            'is_connected', 'interface_connection', 'circuit_termination',
-        ]
-
-    def get_is_connected(self, obj):
-        """
-        Return True if the interface has a connected interface or circuit termination.
-        """
-        if obj.connection:
-            return True
-        try:
-            circuit_termination = obj.circuit_termination
-            return True
-        except CircuitTermination.DoesNotExist:
-            pass
-        return False
-
-    def get_interface_connection(self, obj):
-        if obj.connection:
-            return OrderedDict((
-                ('interface', PeerInterfaceSerializer(obj.connected_interface, context=self.context).data),
-                ('status', obj.connection.connection_status),
-            ))
-        return None
-
-
-class PeerInterfaceSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:interface-detail')
-    device = NestedDeviceSerializer()
-    form_factor = ChoiceFieldSerializer(choices=IFACE_FF_CHOICES)
-    lag = NestedInterfaceSerializer()
-
-    class Meta:
-        model = Interface
-        fields = [
-            'id', 'url', 'device', 'name', 'form_factor', 'enabled', 'lag', 'mtu', 'mac_address', 'mgmt_only',
-            'description',
         ]
 
 
-class WritableInterfaceSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class InterfaceNestedSerializer(InterfaceSerializer):
+    form_factor = serializers.ReadOnlyField(source='get_form_factor_display')
 
-    class Meta:
+    class Meta(InterfaceSerializer.Meta):
-        model = Interface
+        fields = ['id', 'device', 'name']
+
+
+class InterfaceDetailSerializer(InterfaceSerializer):
+    connected_interface = InterfaceSerializer()
+
+    class Meta(InterfaceSerializer.Meta):
         fields = [
-            'id', 'device', 'name', 'form_factor', 'enabled', 'lag', 'mtu', 'mac_address', 'mgmt_only', 'description',
+            'id', 'device', 'name', 'form_factor', 'lag', 'mac_address', 'mgmt_only', 'description', 'is_connected',
+            'connected_interface',
         ]
 
 
@@ -682,45 +451,44 @@ class WritableInterfaceSerializer(ModelValidationMixin, serializers.ModelSeriali
 #
 
 class DeviceBaySerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
-    installed_device = NestedDeviceSerializer()
 
     class Meta:
         model = DeviceBay
-        fields = ['id', 'device', 'name', 'installed_device']
+        fields = ['id', 'device', 'name']
 
 
-class WritableDeviceBaySerializer(ModelValidationMixin, serializers.ModelSerializer):
+class DeviceBayNestedSerializer(DeviceBaySerializer):
+    installed_device = DeviceNestedSerializer()
 
-    class Meta:
+    class Meta(DeviceBaySerializer.Meta):
-        model = DeviceBay
+        fields = ['id', 'name', 'installed_device']
+
+
+class DeviceBayDetailSerializer(DeviceBaySerializer):
+    installed_device = DeviceNestedSerializer()
+
+    class Meta(DeviceBaySerializer.Meta):
         fields = ['id', 'device', 'name', 'installed_device']
 
 
 #
-# Inventory items
+# Modules
 #
 
-class InventoryItemSerializer(serializers.ModelSerializer):
+class ModuleSerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
-    manufacturer = NestedManufacturerSerializer()
+    manufacturer = ManufacturerNestedSerializer()
 
     class Meta:
-        model = InventoryItem
+        model = Module
-        fields = [
+        fields = ['id', 'device', 'parent', 'name', 'manufacturer', 'part_id', 'serial', 'discovered']
-            'id', 'device', 'parent', 'name', 'manufacturer', 'part_id', 'serial', 'asset_tag', 'discovered',
-            'description',
-        ]
 
 
-class WritableInventoryItemSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class ModuleNestedSerializer(ModuleSerializer):
 
-    class Meta:
+    class Meta(ModuleSerializer.Meta):
-        model = InventoryItem
+        fields = ['id', 'device', 'parent', 'name']
-        fields = [
-            'id', 'device', 'parent', 'name', 'manufacturer', 'part_id', 'serial', 'asset_tag', 'discovered',
-            'description',
-        ]
 
 
 #
@@ -728,24 +496,6 @@ class WritableInventoryItemSerializer(ModelValidationMixin, serializers.ModelSer
 #
 
 class InterfaceConnectionSerializer(serializers.ModelSerializer):
-    interface_a = PeerInterfaceSerializer()
-    interface_b = PeerInterfaceSerializer()
-    connection_status = ChoiceFieldSerializer(choices=CONNECTION_STATUS_CHOICES)
-
-    class Meta:
-        model = InterfaceConnection
-        fields = ['id', 'interface_a', 'interface_b', 'connection_status']
-
-
-class NestedInterfaceConnectionSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='dcim-api:interfaceconnection-detail')
-
-    class Meta:
-        model = InterfaceConnection
-        fields = ['id', 'url', 'connection_status']
-
-
-class WritableInterfaceConnectionSerializer(ModelValidationMixin, serializers.ModelSerializer):
 
     class Meta:
         model = InterfaceConnection

netbox/dcim/api/urls.py

@@ -1,64 +1,84 @@
-from __future__ import unicode_literals
+from django.conf.urls import url
 
-from rest_framework import routers
+from extras.models import GRAPH_TYPE_INTERFACE, GRAPH_TYPE_SITE
+from extras.api.views import GraphListView, TopologyMapView
 
-from . import views
+from .views import *
 
 
-class DCIMRootView(routers.APIRootView):
+urlpatterns = [
-    """
-    DCIM API root view
-    """
-    def get_view_name(self):
-        return 'DCIM'
 
+    # Regions
+    url(r'^regions/$', RegionListView.as_view(), name='region_list'),
+    url(r'^regions/(?P<pk>\d+)/$', RegionDetailView.as_view(), name='region_detail'),
 
-router = routers.DefaultRouter()
+    # Sites
-router.APIRootView = DCIMRootView
+    url(r'^sites/$', SiteListView.as_view(), name='site_list'),
+    url(r'^sites/(?P<pk>\d+)/$', SiteDetailView.as_view(), name='site_detail'),
+    url(r'^sites/(?P<pk>\d+)/graphs/$', GraphListView.as_view(), {'type': GRAPH_TYPE_SITE}, name='site_graphs'),
+    url(r'^sites/(?P<site>\d+)/racks/$', RackListView.as_view(), name='site_racks'),
 
-# Sites
+    # Rack groups
-router.register(r'regions', views.RegionViewSet)
+    url(r'^rack-groups/$', RackGroupListView.as_view(), name='rackgroup_list'),
-router.register(r'sites', views.SiteViewSet)
+    url(r'^rack-groups/(?P<pk>\d+)/$', RackGroupDetailView.as_view(), name='rackgroup_detail'),
 
-# Racks
+    # Rack roles
-router.register(r'rack-groups', views.RackGroupViewSet)
+    url(r'^rack-roles/$', RackRoleListView.as_view(), name='rackrole_list'),
-router.register(r'rack-roles', views.RackRoleViewSet)
+    url(r'^rack-roles/(?P<pk>\d+)/$', RackRoleDetailView.as_view(), name='rackrole_detail'),
-router.register(r'racks', views.RackViewSet)
-router.register(r'rack-reservations', views.RackReservationViewSet)
 
-# Device types
+    # Racks
-router.register(r'manufacturers', views.ManufacturerViewSet)
+    url(r'^racks/$', RackListView.as_view(), name='rack_list'),
-router.register(r'device-types', views.DeviceTypeViewSet)
+    url(r'^racks/(?P<pk>\d+)/$', RackDetailView.as_view(), name='rack_detail'),
+    url(r'^racks/(?P<pk>\d+)/rack-units/$', RackUnitListView.as_view(), name='rack_units'),
 
-# Device type components
+    # Rack reservations
-router.register(r'console-port-templates', views.ConsolePortTemplateViewSet)
+    url(r'^rack-reservations/$', RackReservationListView.as_view(), name='rackreservation_list'),
-router.register(r'console-server-port-templates', views.ConsoleServerPortTemplateViewSet)
+    url(r'^rack-reservations/(?P<pk>\d+)/$', RackReservationDetailView.as_view(), name='rackreservation_detail'),
-router.register(r'power-port-templates', views.PowerPortTemplateViewSet)
-router.register(r'power-outlet-templates', views.PowerOutletTemplateViewSet)
-router.register(r'interface-templates', views.InterfaceTemplateViewSet)
-router.register(r'device-bay-templates', views.DeviceBayTemplateViewSet)
 
-# Devices
+    # Manufacturers
-router.register(r'device-roles', views.DeviceRoleViewSet)
+    url(r'^manufacturers/$', ManufacturerListView.as_view(), name='manufacturer_list'),
-router.register(r'platforms', views.PlatformViewSet)
+    url(r'^manufacturers/(?P<pk>\d+)/$', ManufacturerDetailView.as_view(), name='manufacturer_detail'),
-router.register(r'devices', views.DeviceViewSet)
 
-# Device components
+    # Device types
-router.register(r'console-ports', views.ConsolePortViewSet)
+    url(r'^device-types/$', DeviceTypeListView.as_view(), name='devicetype_list'),
-router.register(r'console-server-ports', views.ConsoleServerPortViewSet)
+    url(r'^device-types/(?P<pk>\d+)/$', DeviceTypeDetailView.as_view(), name='devicetype_detail'),
-router.register(r'power-ports', views.PowerPortViewSet)
-router.register(r'power-outlets', views.PowerOutletViewSet)
-router.register(r'interfaces', views.InterfaceViewSet)
-router.register(r'device-bays', views.DeviceBayViewSet)
-router.register(r'inventory-items', views.InventoryItemViewSet)
 
-# Connections
+    # Device roles
-router.register(r'console-connections', views.ConsoleConnectionViewSet, base_name='consoleconnections')
+    url(r'^device-roles/$', DeviceRoleListView.as_view(), name='devicerole_list'),
-router.register(r'power-connections', views.PowerConnectionViewSet, base_name='powerconnections')
+    url(r'^device-roles/(?P<pk>\d+)/$', DeviceRoleDetailView.as_view(), name='devicerole_detail'),
-router.register(r'interface-connections', views.InterfaceConnectionViewSet)
 
-# Miscellaneous
+    # Platforms
-router.register(r'connected-device', views.ConnectedDeviceViewSet, base_name='connected-device')
+    url(r'^platforms/$', PlatformListView.as_view(), name='platform_list'),
+    url(r'^platforms/(?P<pk>\d+)/$', PlatformDetailView.as_view(), name='platform_detail'),
 
-app_name = 'dcim-api'
+    # Devices
-urlpatterns = router.urls
+    url(r'^devices/$', DeviceListView.as_view(), name='device_list'),
+    url(r'^devices/(?P<pk>\d+)/$', DeviceDetailView.as_view(), name='device_detail'),
+    url(r'^devices/(?P<pk>\d+)/lldp-neighbors/$', LLDPNeighborsView.as_view(), name='device_lldp-neighbors'),
+    url(r'^devices/(?P<pk>\d+)/console-ports/$', ConsolePortListView.as_view(), name='device_consoleports'),
+    url(r'^devices/(?P<pk>\d+)/console-server-ports/$', ConsoleServerPortListView.as_view(),
+        name='device_consoleserverports'),
+    url(r'^devices/(?P<pk>\d+)/power-ports/$', PowerPortListView.as_view(), name='device_powerports'),
+    url(r'^devices/(?P<pk>\d+)/power-outlets/$', PowerOutletListView.as_view(), name='device_poweroutlets'),
+    url(r'^devices/(?P<pk>\d+)/interfaces/$', InterfaceListView.as_view(), name='device_interfaces'),
+    url(r'^devices/(?P<pk>\d+)/device-bays/$', DeviceBayListView.as_view(), name='device_devicebays'),
+    url(r'^devices/(?P<pk>\d+)/modules/$', ModuleListView.as_view(), name='device_modules'),
+
+    # Console ports
+    url(r'^console-ports/(?P<pk>\d+)/$', ConsolePortView.as_view(), name='consoleport'),
+
+    # Power ports
+    url(r'^power-ports/(?P<pk>\d+)/$', PowerPortView.as_view(), name='powerport'),
+
+    # Interfaces
+    url(r'^interfaces/(?P<pk>\d+)/$', InterfaceDetailView.as_view(), name='interface_detail'),
+    url(r'^interfaces/(?P<pk>\d+)/graphs/$', GraphListView.as_view(), {'type': GRAPH_TYPE_INTERFACE},
+        name='interface_graphs'),
+    url(r'^interface-connections/$', InterfaceConnectionListView.as_view(), name='interfaceconnection_list'),
+    url(r'^interface-connections/(?P<pk>\d+)/$', InterfaceConnectionView.as_view(), name='interfaceconnection_detail'),
+
+    # Miscellaneous
+    url(r'^related-connections/$', RelatedConnectionsView.as_view(), name='related_connections'),
+    url(r'^topology-maps/(?P<slug>[\w-]+)/$', TopologyMapView.as_view(), name='topology_map'),
+
+]

netbox/dcim/api/views.py

@@ -1,25 +1,23 @@
-from __future__ import unicode_literals
+from rest_framework import generics
-
+from rest_framework.permissions import DjangoModelPermissionsOrAnonReadOnly
-from rest_framework.decorators import detail_route
-from rest_framework.mixins import ListModelMixin
-from rest_framework.permissions import IsAuthenticated
 from rest_framework.response import Response
-from rest_framework.viewsets import GenericViewSet, ModelViewSet, ViewSet
+from rest_framework.settings import api_settings
+from rest_framework.views import APIView
 
 from django.conf import settings
+from django.contrib.contenttypes.models import ContentType
+from django.http import Http404
 from django.shortcuts import get_object_or_404
 
 from dcim.models import (
-    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceBay,
+    ConsolePort, ConsoleServerPort, Device, DeviceBay, DeviceRole, DeviceType, Interface, InterfaceConnection,
-    DeviceBayTemplate, DeviceRole, DeviceType, Interface, InterfaceConnection, InterfaceTemplate, Manufacturer,
+    Manufacturer, Module, Platform, PowerOutlet, PowerPort, Rack, RackGroup, RackReservation, RackRole, Region, Site,
-    InventoryItem, Platform, PowerOutlet, PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack, RackGroup,
+    VIRTUAL_IFACE_TYPES,
-    RackReservation, RackRole, Region, Site,
 )
 from dcim import filters
-from extras.api.serializers import RenderedGraphSerializer
+from extras.api.views import CustomFieldModelAPIView
-from extras.api.views import CustomFieldModelViewSet
+from extras.api.renderers import BINDZoneRenderer, FlatJSONRenderer
-from extras.models import Graph, GRAPH_TYPE_INTERFACE, GRAPH_TYPE_SITE
+from utilities.api import ServiceUnavailable
-from utilities.api import ServiceUnavailable, WritableSerializerMixin
 from .exceptions import MissingFilterException
 from . import serializers
 
@@ -28,70 +26,117 @@ from . import serializers
 # Regions
 #
 
-class RegionViewSet(WritableSerializerMixin, ModelViewSet):
+class RegionListView(generics.ListAPIView):
+    """
+    List all regions
+    """
+    queryset = Region.objects.all()
+    serializer_class = serializers.RegionSerializer
+
+
+class RegionDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single region
+    """
     queryset = Region.objects.all()
     serializer_class = serializers.RegionSerializer
-    write_serializer_class = serializers.WritableRegionSerializer
-    filter_class = filters.RegionFilter
 
 
 #
 # Sites
 #
 
-class SiteViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class SiteListView(CustomFieldModelAPIView, generics.ListAPIView):
-    queryset = Site.objects.select_related('region', 'tenant')
+    """
+    List all sites
+    """
+    queryset = Site.objects.select_related('tenant').prefetch_related('custom_field_values__field')
     serializer_class = serializers.SiteSerializer
-    write_serializer_class = serializers.WritableSiteSerializer
-    filter_class = filters.SiteFilter
 
-    @detail_route()
+
-    def graphs(self, request, pk=None):
+class SiteDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
-        A convenience method for rendering graphs for a particular site.
+    Retrieve a single site
     """
-        site = get_object_or_404(Site, pk=pk)
+    queryset = Site.objects.select_related('tenant').prefetch_related('custom_field_values__field')
-        queryset = Graph.objects.filter(type=GRAPH_TYPE_SITE)
+    serializer_class = serializers.SiteSerializer
-        serializer = RenderedGraphSerializer(queryset, many=True, context={'graphed_object': site})
-        return Response(serializer.data)
 
 
 #
 # Rack groups
 #
 
-class RackGroupViewSet(WritableSerializerMixin, ModelViewSet):
+class RackGroupListView(generics.ListAPIView):
+    """
+    List all rack groups
+    """
     queryset = RackGroup.objects.select_related('site')
     serializer_class = serializers.RackGroupSerializer
-    write_serializer_class = serializers.WritableRackGroupSerializer
     filter_class = filters.RackGroupFilter
 
 
+class RackGroupDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single rack group
+    """
+    queryset = RackGroup.objects.select_related('site')
+    serializer_class = serializers.RackGroupSerializer
+
+
 #
 # Rack roles
 #
 
-class RackRoleViewSet(ModelViewSet):
+class RackRoleListView(generics.ListAPIView):
+    """
+    List all rack roles
+    """
+    queryset = RackRole.objects.all()
+    serializer_class = serializers.RackRoleSerializer
+
+
+class RackRoleDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single rack role
+    """
     queryset = RackRole.objects.all()
     serializer_class = serializers.RackRoleSerializer
-    filter_class = filters.RackRoleFilter
 
 
 #
 # Racks
 #
 
-class RackViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class RackListView(CustomFieldModelAPIView, generics.ListAPIView):
-    queryset = Rack.objects.select_related('site', 'group__site', 'tenant')
+    """
+    List racks (filterable)
+    """
+    queryset = Rack.objects.select_related('site', 'group__site', 'tenant')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.RackSerializer
-    write_serializer_class = serializers.WritableRackSerializer
     filter_class = filters.RackFilter
 
-    @detail_route()
+
-    def units(self, request, pk=None):
+class RackDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
+    """
+    Retrieve a single rack
+    """
+    queryset = Rack.objects.select_related('site', 'group__site', 'tenant')\
+        .prefetch_related('custom_field_values__field')
+    serializer_class = serializers.RackDetailSerializer
+
+
+#
+# Rack units
+#
+
+class RackUnitListView(APIView):
     """
     List rack units (by rack)
     """
+
+    def get(self, request, pk):
+
         rack = get_object_or_404(Rack, pk=pk)
         face = request.GET.get('face', 0)
         exclude_pk = request.GET.get('exclude', None)
@@ -102,267 +147,398 @@ class RackViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
                 exclude_pk = None
         elevation = rack.get_rack_units(face, exclude_pk)
 
-        page = self.paginate_queryset(elevation)
+        # Serialize Devices within the rack elevation
-        if page is not None:
+        for u in elevation:
-            rack_units = serializers.RackUnitSerializer(page, many=True, context={'request': request})
+            if u['device']:
-            return self.get_paginated_response(rack_units.data)
+                u['device'] = serializers.DeviceNestedSerializer(instance=u['device']).data
+
+        return Response(elevation)
 
 
 #
 # Rack reservations
 #
 
-class RackReservationViewSet(WritableSerializerMixin, ModelViewSet):
+class RackReservationListView(generics.ListAPIView):
-    queryset = RackReservation.objects.select_related('rack')
+    """
+    List all rack reservation
+    """
+    queryset = RackReservation.objects.all()
     serializer_class = serializers.RackReservationSerializer
-    write_serializer_class = serializers.WritableRackReservationSerializer
     filter_class = filters.RackReservationFilter
 
-    # Assign user from request
+
-    def perform_create(self, serializer):
+class RackReservationDetailView(generics.RetrieveAPIView):
-        serializer.save(user=self.request.user)
+    """
+    Retrieve a single rack reservation
+    """
+    queryset = RackReservation.objects.all()
+    serializer_class = serializers.RackReservationSerializer
 
 
 #
 # Manufacturers
 #
 
-class ManufacturerViewSet(ModelViewSet):
+class ManufacturerListView(generics.ListAPIView):
+    """
+    List all hardware manufacturers
+    """
+    queryset = Manufacturer.objects.all()
+    serializer_class = serializers.ManufacturerSerializer
+
+
+class ManufacturerDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single hardware manufacturers
+    """
     queryset = Manufacturer.objects.all()
     serializer_class = serializers.ManufacturerSerializer
-    filter_class = filters.ManufacturerFilter
 
 
 #
-# Device types
+# Device Types
 #
 
-class DeviceTypeViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class DeviceTypeListView(CustomFieldModelAPIView, generics.ListAPIView):
-    queryset = DeviceType.objects.select_related('manufacturer')
+    """
+    List device types (filterable)
+    """
+    queryset = DeviceType.objects.select_related('manufacturer').prefetch_related('custom_field_values__field')
     serializer_class = serializers.DeviceTypeSerializer
-    write_serializer_class = serializers.WritableDeviceTypeSerializer
     filter_class = filters.DeviceTypeFilter
 
 
-#
+class DeviceTypeDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
-# Device type components
+    """
-#
+    Retrieve a single device type
-
+    """
-class ConsolePortTemplateViewSet(WritableSerializerMixin, ModelViewSet):
+    queryset = DeviceType.objects.select_related('manufacturer').prefetch_related('custom_field_values__field')
-    queryset = ConsolePortTemplate.objects.select_related('device_type__manufacturer')
+    serializer_class = serializers.DeviceTypeDetailSerializer
-    serializer_class = serializers.ConsolePortTemplateSerializer
-    write_serializer_class = serializers.WritableConsolePortTemplateSerializer
-    filter_class = filters.ConsolePortTemplateFilter
-
-
-class ConsoleServerPortTemplateViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = ConsoleServerPortTemplate.objects.select_related('device_type__manufacturer')
-    serializer_class = serializers.ConsoleServerPortTemplateSerializer
-    write_serializer_class = serializers.WritableConsoleServerPortTemplateSerializer
-    filter_class = filters.ConsoleServerPortTemplateFilter
-
-
-class PowerPortTemplateViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = PowerPortTemplate.objects.select_related('device_type__manufacturer')
-    serializer_class = serializers.PowerPortTemplateSerializer
-    write_serializer_class = serializers.WritablePowerPortTemplateSerializer
-    filter_class = filters.PowerPortTemplateFilter
-
-
-class PowerOutletTemplateViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = PowerOutletTemplate.objects.select_related('device_type__manufacturer')
-    serializer_class = serializers.PowerOutletTemplateSerializer
-    write_serializer_class = serializers.WritablePowerOutletTemplateSerializer
-    filter_class = filters.PowerOutletTemplateFilter
-
-
-class InterfaceTemplateViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = InterfaceTemplate.objects.select_related('device_type__manufacturer')
-    serializer_class = serializers.InterfaceTemplateSerializer
-    write_serializer_class = serializers.WritableInterfaceTemplateSerializer
-    filter_class = filters.InterfaceTemplateFilter
-
-
-class DeviceBayTemplateViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = DeviceBayTemplate.objects.select_related('device_type__manufacturer')
-    serializer_class = serializers.DeviceBayTemplateSerializer
-    write_serializer_class = serializers.WritableDeviceBayTemplateSerializer
-    filter_class = filters.DeviceBayTemplateFilter
 
 
 #
 # Device roles
 #
 
-class DeviceRoleViewSet(ModelViewSet):
+class DeviceRoleListView(generics.ListAPIView):
+    """
+    List all device roles
+    """
+    queryset = DeviceRole.objects.all()
+    serializer_class = serializers.DeviceRoleSerializer
+
+
+class DeviceRoleDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single device role
+    """
     queryset = DeviceRole.objects.all()
     serializer_class = serializers.DeviceRoleSerializer
-    filter_class = filters.DeviceRoleFilter
 
 
 #
 # Platforms
 #
 
-class PlatformViewSet(ModelViewSet):
+class PlatformListView(generics.ListAPIView):
+    """
+    List all platforms
+    """
+    queryset = Platform.objects.all()
+    serializer_class = serializers.PlatformSerializer
+
+
+class PlatformDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single platform
+    """
     queryset = Platform.objects.all()
     serializer_class = serializers.PlatformSerializer
-    filter_class = filters.PlatformFilter
 
 
 #
 # Devices
 #
 
-class DeviceViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class DeviceListView(CustomFieldModelAPIView, generics.ListAPIView):
+    """
+    List devices (filterable)
+    """
     queryset = Device.objects.select_related(
-        'device_type__manufacturer', 'device_role', 'tenant', 'platform', 'site', 'rack', 'parent_bay',
+        'device_type__manufacturer', 'device_role', 'tenant', 'platform', 'site', 'rack', 'parent_bay'
     ).prefetch_related(
-        'primary_ip4__nat_outside', 'primary_ip6__nat_outside',
+        'primary_ip4__nat_outside', 'primary_ip6__nat_outside', 'custom_field_values__field'
     )
     serializer_class = serializers.DeviceSerializer
-    write_serializer_class = serializers.WritableDeviceSerializer
     filter_class = filters.DeviceFilter
+    renderer_classes = api_settings.DEFAULT_RENDERER_CLASSES + [BINDZoneRenderer, FlatJSONRenderer]
 
-    @detail_route(url_path='lldp-neighbors')
+
-    def lldp_neighbors(self, request, pk):
+class DeviceDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
+    """
+    Retrieve a single device
+    """
+    queryset = Device.objects.select_related(
+        'device_type__manufacturer', 'device_role', 'tenant', 'platform', 'site', 'rack', 'parent_bay'
+    ).prefetch_related('custom_field_values__field')
+    serializer_class = serializers.DeviceSerializer
+
+
+#
+# Console ports
+#
+
+class ConsolePortListView(generics.ListAPIView):
+    """
+    List console ports (by device)
+    """
+    serializer_class = serializers.ConsolePortSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return ConsolePort.objects.filter(device=device).select_related('cs_port')
+
+
+class ConsolePortView(generics.RetrieveUpdateDestroyAPIView):
+    permission_classes = [DjangoModelPermissionsOrAnonReadOnly]
+    serializer_class = serializers.ConsolePortSerializer
+    queryset = ConsolePort.objects.all()
+
+
+#
+# Console server ports
+#
+
+class ConsoleServerPortListView(generics.ListAPIView):
+    """
+    List console server ports (by device)
+    """
+    serializer_class = serializers.ConsoleServerPortSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return ConsoleServerPort.objects.filter(device=device).select_related('connected_console')
+
+
+#
+# Power ports
+#
+
+class PowerPortListView(generics.ListAPIView):
+    """
+    List power ports (by device)
+    """
+    serializer_class = serializers.PowerPortSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return PowerPort.objects.filter(device=device).select_related('power_outlet')
+
+
+class PowerPortView(generics.RetrieveUpdateDestroyAPIView):
+    permission_classes = [DjangoModelPermissionsOrAnonReadOnly]
+    serializer_class = serializers.PowerPortSerializer
+    queryset = PowerPort.objects.all()
+
+
+#
+# Power outlets
+#
+
+class PowerOutletListView(generics.ListAPIView):
+    """
+    List power outlets (by device)
+    """
+    serializer_class = serializers.PowerOutletSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return PowerOutlet.objects.filter(device=device).select_related('connected_port')
+
+
+#
+# Interfaces
+#
+
+class InterfaceListView(generics.ListAPIView):
+    """
+    List interfaces (by device)
+    """
+    serializer_class = serializers.InterfaceSerializer
+    filter_class = filters.InterfaceFilter
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        queryset = Interface.objects.order_naturally(device.device_type.interface_ordering).filter(device=device)\
+            .select_related('connected_as_a', 'connected_as_b', 'circuit_termination')
+
+        # Filter by type (physical or virtual)
+        iface_type = self.request.query_params.get('type')
+        if iface_type == 'physical':
+            queryset = queryset.exclude(form_factor__in=VIRTUAL_IFACE_TYPES)
+        elif iface_type == 'virtual':
+            queryset = queryset.filter(form_factor__in=VIRTUAL_IFACE_TYPES)
+        elif iface_type is not None:
+            queryset = queryset.empty()
+
+        return queryset
+
+
+class InterfaceDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single interface
+    """
+    queryset = Interface.objects.select_related('device')
+    serializer_class = serializers.InterfaceDetailSerializer
+
+
+class InterfaceConnectionView(generics.RetrieveUpdateDestroyAPIView):
+    permission_classes = [DjangoModelPermissionsOrAnonReadOnly]
+    serializer_class = serializers.InterfaceConnectionSerializer
+    queryset = InterfaceConnection.objects.all()
+
+
+class InterfaceConnectionListView(generics.ListAPIView):
+    """
+    Retrieve a list of all interface connections
+    """
+    serializer_class = serializers.InterfaceConnectionSerializer
+    queryset = InterfaceConnection.objects.all()
+
+
+#
+# Device bays
+#
+
+class DeviceBayListView(generics.ListAPIView):
+    """
+    List device bays (by device)
+    """
+    serializer_class = serializers.DeviceBayNestedSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return DeviceBay.objects.filter(device=device).select_related('installed_device')
+
+
+#
+# Modules
+#
+
+class ModuleListView(generics.ListAPIView):
+    """
+    List device modules (by device)
+    """
+    serializer_class = serializers.ModuleSerializer
+
+    def get_queryset(self):
+
+        device = get_object_or_404(Device, pk=self.kwargs['pk'])
+        return Module.objects.filter(device=device).select_related('device', 'manufacturer')
+
+
+#
+# Live queries
+#
+
+class LLDPNeighborsView(APIView):
     """
     Retrieve live LLDP neighbors of a device
     """
+
+    def get(self, request, pk):
+
         device = get_object_or_404(Device, pk=pk)
         if not device.primary_ip:
-            raise ServiceUnavailable("No IP configured for this device.")
+            raise ServiceUnavailable(detail="No IP configured for this device.")
 
         RPC = device.get_rpc_client()
         if not RPC:
-            raise ServiceUnavailable("No RPC client available for this platform ({}).".format(device.platform))
+            raise ServiceUnavailable(detail="No RPC client available for this platform ({}).".format(device.platform))
 
         # Connect to device and retrieve inventory info
         try:
             with RPC(device, username=settings.NETBOX_USERNAME, password=settings.NETBOX_PASSWORD) as rpc_client:
                 lldp_neighbors = rpc_client.get_lldp_neighbors()
         except:
-            raise ServiceUnavailable("Error connecting to the remote device.")
+            raise ServiceUnavailable(detail="Error connecting to the remote device.")
 
         return Response(lldp_neighbors)
 
 
-#
-# Device components
-#
-
-class ConsolePortViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = ConsolePort.objects.select_related('device', 'cs_port__device')
-    serializer_class = serializers.ConsolePortSerializer
-    write_serializer_class = serializers.WritableConsolePortSerializer
-    filter_class = filters.ConsolePortFilter
-
-
-class ConsoleServerPortViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = ConsoleServerPort.objects.select_related('device', 'connected_console__device')
-    serializer_class = serializers.ConsoleServerPortSerializer
-    write_serializer_class = serializers.WritableConsoleServerPortSerializer
-    filter_class = filters.ConsoleServerPortFilter
-
-
-class PowerPortViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = PowerPort.objects.select_related('device', 'power_outlet__device')
-    serializer_class = serializers.PowerPortSerializer
-    write_serializer_class = serializers.WritablePowerPortSerializer
-    filter_class = filters.PowerPortFilter
-
-
-class PowerOutletViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = PowerOutlet.objects.select_related('device', 'connected_port__device')
-    serializer_class = serializers.PowerOutletSerializer
-    write_serializer_class = serializers.WritablePowerOutletSerializer
-    filter_class = filters.PowerOutletFilter
-
-
-class InterfaceViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = Interface.objects.select_related('device')
-    serializer_class = serializers.InterfaceSerializer
-    write_serializer_class = serializers.WritableInterfaceSerializer
-    filter_class = filters.InterfaceFilter
-
-    @detail_route()
-    def graphs(self, request, pk=None):
-        """
-        A convenience method for rendering graphs for a particular interface.
-        """
-        interface = get_object_or_404(Interface, pk=pk)
-        queryset = Graph.objects.filter(type=GRAPH_TYPE_INTERFACE)
-        serializer = RenderedGraphSerializer(queryset, many=True, context={'graphed_object': interface})
-        return Response(serializer.data)
-
-
-class DeviceBayViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = DeviceBay.objects.select_related('installed_device')
-    serializer_class = serializers.DeviceBaySerializer
-    write_serializer_class = serializers.WritableDeviceBaySerializer
-    filter_class = filters.DeviceBayFilter
-
-
-class InventoryItemViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = InventoryItem.objects.select_related('device', 'manufacturer')
-    serializer_class = serializers.InventoryItemSerializer
-    write_serializer_class = serializers.WritableInventoryItemSerializer
-    filter_class = filters.InventoryItemFilter
-
-
-#
-# Connections
-#
-
-class ConsoleConnectionViewSet(ListModelMixin, GenericViewSet):
-    queryset = ConsolePort.objects.select_related('device', 'cs_port__device').filter(cs_port__isnull=False)
-    serializer_class = serializers.ConsolePortSerializer
-    filter_class = filters.ConsoleConnectionFilter
-
-
-class PowerConnectionViewSet(ListModelMixin, GenericViewSet):
-    queryset = PowerPort.objects.select_related('device', 'power_outlet__device').filter(power_outlet__isnull=False)
-    serializer_class = serializers.PowerPortSerializer
-    filter_class = filters.PowerConnectionFilter
-
-
-class InterfaceConnectionViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = InterfaceConnection.objects.select_related('interface_a__device', 'interface_b__device')
-    serializer_class = serializers.InterfaceConnectionSerializer
-    write_serializer_class = serializers.WritableInterfaceConnectionSerializer
-    filter_class = filters.InterfaceConnectionFilter
-
-
 #
 # Miscellaneous
 #
 
-class ConnectedDeviceViewSet(ViewSet):
+class RelatedConnectionsView(APIView):
     """
-    This endpoint allows a user to determine what device (if any) is connected to a given peer device and peer
+    Retrieve all connections related to a given console/power/interface connection
-    interface. This is useful in a situation where a device boots with no configuration, but can detect its neighbors
-    via a protocol such as LLDP. Two query parameters must be included in the request:
-
-    * `peer-device`: The name of the peer device
-    * `peer-interface`: The name of the peer interface
     """
-    permission_classes = [IsAuthenticated]
 
-    def get_view_name(self):
+    def __init__(self):
-        return "Connected Device Locator"
+        super(RelatedConnectionsView, self).__init__()
 
-    def list(self, request):
+        # Custom fields
+        self.content_type = ContentType.objects.get_for_model(Device)
+        self.custom_fields = self.content_type.custom_fields.prefetch_related('choices')
 
-        peer_device_name = request.query_params.get('peer-device')
+    def get(self, request):
-        peer_interface_name = request.query_params.get('peer-interface')
+
-        if not peer_device_name or not peer_interface_name:
+        peer_device = request.GET.get('peer-device')
-            raise MissingFilterException(detail='Request must include "peer-device" and "peer-interface" filters.')
+        peer_interface = request.GET.get('peer-interface')
+
+        # Search by interface
+        if peer_device and peer_interface:
 
             # Determine local interface from peer interface's connection
-        peer_interface = get_object_or_404(Interface, device__name=peer_device_name, name=peer_interface_name)
+            try:
-        local_interface = peer_interface.connected_interface
+                peer_iface = Interface.objects.get(device__name=peer_device, name=peer_interface)
-
+            except Interface.DoesNotExist:
-        if local_interface is None:
+                raise Http404()
+            local_iface = peer_iface.connected_interface
+            if local_iface:
+                device = local_iface.device
+            else:
                 return Response()
 
-        return Response(serializers.DeviceSerializer(local_interface.device, context={'request': request}).data)
+        else:
+            raise MissingFilterException(detail='Must specify search parameters "peer-device" and "peer-interface".')
+
+        # Initialize response skeleton
+        response = {
+            'device': serializers.DeviceSerializer(device, context={'view': self}).data,
+            'console-ports': [],
+            'power-ports': [],
+            'interfaces': [],
+        }
+
+        # Console connections
+        console_ports = ConsolePort.objects.filter(device=device).select_related('cs_port__device')
+        for cp in console_ports:
+            data = serializers.ConsolePortSerializer(instance=cp).data
+            del(data['device'])
+            response['console-ports'].append(data)
+
+        # Power connections
+        power_ports = PowerPort.objects.filter(device=device).select_related('power_outlet__device')
+        for pp in power_ports:
+            data = serializers.PowerPortSerializer(instance=pp).data
+            del(data['device'])
+            response['power-ports'].append(data)
+
+        # Interface connections
+        interfaces = Interface.objects.order_naturally(device.device_type.interface_ordering).filter(device=device)\
+            .select_related('connected_as_a', 'connected_as_b', 'circuit_termination')
+        for iface in interfaces:
+            data = serializers.InterfaceDetailSerializer(instance=iface).data
+            del(data['device'])
+            response['interfaces'].append(data)
+
+        return Response(response)

netbox/dcim/apps.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from django.apps import AppConfig
 
 

netbox/dcim/constants.py

@@ -1,230 +0,0 @@
-from __future__ import unicode_literals
-
-
-# Rack types
-RACK_TYPE_2POST = 100
-RACK_TYPE_4POST = 200
-RACK_TYPE_CABINET = 300
-RACK_TYPE_WALLFRAME = 1000
-RACK_TYPE_WALLCABINET = 1100
-RACK_TYPE_CHOICES = (
-    (RACK_TYPE_2POST, '2-post frame'),
-    (RACK_TYPE_4POST, '4-post frame'),
-    (RACK_TYPE_CABINET, '4-post cabinet'),
-    (RACK_TYPE_WALLFRAME, 'Wall-mounted frame'),
-    (RACK_TYPE_WALLCABINET, 'Wall-mounted cabinet'),
-)
-
-# Rack widths
-RACK_WIDTH_19IN = 19
-RACK_WIDTH_23IN = 23
-RACK_WIDTH_CHOICES = (
-    (RACK_WIDTH_19IN, '19 inches'),
-    (RACK_WIDTH_23IN, '23 inches'),
-)
-
-# Rack faces
-RACK_FACE_FRONT = 0
-RACK_FACE_REAR = 1
-RACK_FACE_CHOICES = [
-    [RACK_FACE_FRONT, 'Front'],
-    [RACK_FACE_REAR, 'Rear'],
-]
-
-# Parent/child device roles
-SUBDEVICE_ROLE_PARENT = True
-SUBDEVICE_ROLE_CHILD = False
-SUBDEVICE_ROLE_CHOICES = (
-    (None, 'None'),
-    (SUBDEVICE_ROLE_PARENT, 'Parent'),
-    (SUBDEVICE_ROLE_CHILD, 'Child'),
-)
-
-# Interface ordering schemes (for device types)
-IFACE_ORDERING_POSITION = 1
-IFACE_ORDERING_NAME = 2
-IFACE_ORDERING_CHOICES = [
-    [IFACE_ORDERING_POSITION, 'Slot/position'],
-    [IFACE_ORDERING_NAME, 'Name (alphabetically)']
-]
-
-# Interface form factors
-# Virtual
-IFACE_FF_VIRTUAL = 0
-IFACE_FF_LAG = 200
-# Ethernet
-IFACE_FF_100ME_FIXED = 800
-IFACE_FF_1GE_FIXED = 1000
-IFACE_FF_1GE_GBIC = 1050
-IFACE_FF_1GE_SFP = 1100
-IFACE_FF_10GE_FIXED = 1150
-IFACE_FF_10GE_SFP_PLUS = 1200
-IFACE_FF_10GE_XFP = 1300
-IFACE_FF_10GE_XENPAK = 1310
-IFACE_FF_10GE_X2 = 1320
-IFACE_FF_25GE_SFP28 = 1350
-IFACE_FF_40GE_QSFP_PLUS = 1400
-IFACE_FF_100GE_CFP = 1500
-IFACE_FF_100GE_QSFP28 = 1600
-# Wireless
-IFACE_FF_80211A = 2600
-IFACE_FF_80211G = 2610
-IFACE_FF_80211N = 2620
-IFACE_FF_80211AC = 2630
-IFACE_FF_80211AD = 2640
-# Fibrechannel
-IFACE_FF_1GFC_SFP = 3010
-IFACE_FF_2GFC_SFP = 3020
-IFACE_FF_4GFC_SFP = 3040
-IFACE_FF_8GFC_SFP_PLUS = 3080
-IFACE_FF_16GFC_SFP_PLUS = 3160
-# Serial
-IFACE_FF_T1 = 4000
-IFACE_FF_E1 = 4010
-IFACE_FF_T3 = 4040
-IFACE_FF_E3 = 4050
-# Stacking
-IFACE_FF_STACKWISE = 5000
-IFACE_FF_STACKWISE_PLUS = 5050
-IFACE_FF_FLEXSTACK = 5100
-IFACE_FF_FLEXSTACK_PLUS = 5150
-IFACE_FF_JUNIPER_VCP = 5200
-# Other
-IFACE_FF_OTHER = 32767
-
-IFACE_FF_CHOICES = [
-    [
-        'Virtual interfaces',
-        [
-            [IFACE_FF_VIRTUAL, 'Virtual'],
-            [IFACE_FF_LAG, 'Link Aggregation Group (LAG)'],
-        ]
-    ],
-    [
-        'Ethernet (fixed)',
-        [
-            [IFACE_FF_100ME_FIXED, '100BASE-TX (10/100ME)'],
-            [IFACE_FF_1GE_FIXED, '1000BASE-T (1GE)'],
-            [IFACE_FF_10GE_FIXED, '10GBASE-T (10GE)'],
-        ]
-    ],
-    [
-        'Ethernet (modular)',
-        [
-            [IFACE_FF_1GE_GBIC, 'GBIC (1GE)'],
-            [IFACE_FF_1GE_SFP, 'SFP (1GE)'],
-            [IFACE_FF_10GE_SFP_PLUS, 'SFP+ (10GE)'],
-            [IFACE_FF_10GE_XFP, 'XFP (10GE)'],
-            [IFACE_FF_10GE_XENPAK, 'XENPAK (10GE)'],
-            [IFACE_FF_10GE_X2, 'X2 (10GE)'],
-            [IFACE_FF_25GE_SFP28, 'SFP28 (25GE)'],
-            [IFACE_FF_40GE_QSFP_PLUS, 'QSFP+ (40GE)'],
-            [IFACE_FF_100GE_CFP, 'CFP (100GE)'],
-            [IFACE_FF_100GE_QSFP28, 'QSFP28 (100GE)'],
-        ]
-    ],
-    [
-        'Wireless',
-        [
-            [IFACE_FF_80211A, 'IEEE 802.11a'],
-            [IFACE_FF_80211G, 'IEEE 802.11b/g'],
-            [IFACE_FF_80211N, 'IEEE 802.11n'],
-            [IFACE_FF_80211AC, 'IEEE 802.11ac'],
-            [IFACE_FF_80211AD, 'IEEE 802.11ad'],
-        ]
-    ],
-    [
-        'FibreChannel',
-        [
-            [IFACE_FF_1GFC_SFP, 'SFP (1GFC)'],
-            [IFACE_FF_2GFC_SFP, 'SFP (2GFC)'],
-            [IFACE_FF_4GFC_SFP, 'SFP (4GFC)'],
-            [IFACE_FF_8GFC_SFP_PLUS, 'SFP+ (8GFC)'],
-            [IFACE_FF_16GFC_SFP_PLUS, 'SFP+ (16GFC)'],
-        ]
-    ],
-    [
-        'Serial',
-        [
-            [IFACE_FF_T1, 'T1 (1.544 Mbps)'],
-            [IFACE_FF_E1, 'E1 (2.048 Mbps)'],
-            [IFACE_FF_T3, 'T3 (45 Mbps)'],
-            [IFACE_FF_E3, 'E3 (34 Mbps)'],
-        ]
-    ],
-    [
-        'Stacking',
-        [
-            [IFACE_FF_STACKWISE, 'Cisco StackWise'],
-            [IFACE_FF_STACKWISE_PLUS, 'Cisco StackWise Plus'],
-            [IFACE_FF_FLEXSTACK, 'Cisco FlexStack'],
-            [IFACE_FF_FLEXSTACK_PLUS, 'Cisco FlexStack Plus'],
-            [IFACE_FF_JUNIPER_VCP, 'Juniper VCP'],
-        ]
-    ],
-    [
-        'Other',
-        [
-            [IFACE_FF_OTHER, 'Other'],
-        ]
-    ],
-]
-
-VIRTUAL_IFACE_TYPES = [
-    IFACE_FF_VIRTUAL,
-    IFACE_FF_LAG,
-]
-
-WIRELESS_IFACE_TYPES = [
-    IFACE_FF_80211A,
-    IFACE_FF_80211G,
-    IFACE_FF_80211N,
-    IFACE_FF_80211AC,
-    IFACE_FF_80211AD,
-]
-
-NONCONNECTABLE_IFACE_TYPES = VIRTUAL_IFACE_TYPES + WIRELESS_IFACE_TYPES
-
-# Device statuses
-STATUS_OFFLINE = 0
-STATUS_ACTIVE = 1
-STATUS_PLANNED = 2
-STATUS_STAGED = 3
-STATUS_FAILED = 4
-STATUS_INVENTORY = 5
-STATUS_CHOICES = [
-    [STATUS_ACTIVE, 'Active'],
-    [STATUS_OFFLINE, 'Offline'],
-    [STATUS_PLANNED, 'Planned'],
-    [STATUS_STAGED, 'Staged'],
-    [STATUS_FAILED, 'Failed'],
-    [STATUS_INVENTORY, 'Inventory'],
-]
-
-# Bootstrap CSS classes for device stasuses
-DEVICE_STATUS_CLASSES = {
-    0: 'warning',
-    1: 'success',
-    2: 'info',
-    3: 'primary',
-    4: 'danger',
-    5: 'default',
-}
-
-# Console/power/interface connection statuses
-CONNECTION_STATUS_PLANNED = False
-CONNECTION_STATUS_CONNECTED = True
-CONNECTION_STATUS_CHOICES = [
-    [CONNECTION_STATUS_PLANNED, 'Planned'],
-    [CONNECTION_STATUS_CONNECTED, 'Connected'],
-]
-
-# Platform -> RPC client mappings
-RPC_CLIENT_JUNIPER_JUNOS = 'juniper-junos'
-RPC_CLIENT_CISCO_IOS = 'cisco-ios'
-RPC_CLIENT_OPENGEAR = 'opengear'
-RPC_CLIENT_CHOICES = [
-    [RPC_CLIENT_JUNIPER_JUNOS, 'Juniper Junos (NETCONF)'],
-    [RPC_CLIENT_CISCO_IOS, 'Cisco IOS (SSH)'],
-    [RPC_CLIENT_OPENGEAR, 'Opengear (SSH)'],
-]

netbox/dcim/fields.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from netaddr import EUI, mac_unix_expanded
 
 from django.core.exceptions import ValidationError

netbox/dcim/filters.py

@@ -1,39 +1,18 @@
-from __future__ import unicode_literals
-
 import django_filters
 from netaddr.core import AddrFormatError
 
-from django.contrib.auth.models import User
 from django.db.models import Q
 
 from extras.filters import CustomFieldFilterSet
 from tenancy.models import Tenant
 from utilities.filters import NullableModelMultipleChoiceFilter, NumericInFilter
 from .models import (
-    ConsolePort, ConsolePortTemplate, ConsoleServerPort, ConsoleServerPortTemplate, Device, DeviceBay,
+    ConsolePort, ConsoleServerPort, Device, DeviceRole, DeviceType, IFACE_FF_LAG, Interface, InterfaceConnection,
-    DeviceBayTemplate, DeviceRole, DeviceType, STATUS_CHOICES, IFACE_FF_LAG, Interface, InterfaceConnection,
+    Manufacturer, Platform, PowerOutlet, PowerPort, Rack, RackGroup, RackReservation, RackRole, Region, Site,
-    InterfaceTemplate, Manufacturer, InventoryItem, NONCONNECTABLE_IFACE_TYPES, Platform, PowerOutlet,
+    VIRTUAL_IFACE_TYPES,
-    PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack, RackGroup, RackReservation, RackRole, Region, Site,
-    VIRTUAL_IFACE_TYPES, WIRELESS_IFACE_TYPES,
 )
 
 
-class RegionFilter(django_filters.FilterSet):
-    parent_id = NullableModelMultipleChoiceFilter(
-        queryset=Region.objects.all(),
-        label='Parent region (ID)',
-    )
-    parent = NullableModelMultipleChoiceFilter(
-        queryset=Region.objects.all(),
-        to_field_name='slug',
-        label='Parent region (slug)',
-    )
-
-    class Meta:
-        model = Region
-        fields = ['name', 'slug']
-
-
 class SiteFilter(CustomFieldFilterSet, django_filters.FilterSet):
     id__in = NumericInFilter(name='id', lookup_expr='in')
     q = django_filters.CharFilter(
@@ -41,19 +20,23 @@ class SiteFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Search',
     )
     region_id = NullableModelMultipleChoiceFilter(
+        name='region',
         queryset=Region.objects.all(),
         label='Region (ID)',
     )
     region = NullableModelMultipleChoiceFilter(
+        name='region',
         queryset=Region.objects.all(),
         to_field_name='slug',
         label='Region (slug)',
     )
     tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         label='Tenant (ID)',
     )
     tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         to_field_name='slug',
         label='Tenant (slug)',
@@ -61,7 +44,7 @@ class SiteFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
     class Meta:
         model = Site
-        fields = ['q', 'name', 'slug', 'facility', 'asn', 'contact_name', 'contact_phone', 'contact_email']
+        fields = ['q', 'name', 'facility', 'asn']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -71,9 +54,6 @@ class SiteFilter(CustomFieldFilterSet, django_filters.FilterSet):
             Q(facility__icontains=value) |
             Q(physical_address__icontains=value) |
             Q(shipping_address__icontains=value) |
-            Q(contact_name__icontains=value) |
-            Q(contact_phone__icontains=value) |
-            Q(contact_email__icontains=value) |
             Q(comments__icontains=value)
         )
         try:
@@ -85,6 +65,7 @@ class SiteFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
 class RackGroupFilter(django_filters.FilterSet):
     site_id = django_filters.ModelMultipleChoiceFilter(
+        name='site',
         queryset=Site.objects.all(),
         label='Site (ID)',
     )
@@ -97,14 +78,7 @@ class RackGroupFilter(django_filters.FilterSet):
 
     class Meta:
         model = RackGroup
-        fields = ['site_id', 'name', 'slug']
+        fields = ['name']
-
-
-class RackRoleFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = RackRole
-        fields = ['name', 'slug', 'color']
 
 
 class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
@@ -114,6 +88,7 @@ class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Search',
     )
     site_id = django_filters.ModelMultipleChoiceFilter(
+        name='site',
         queryset=Site.objects.all(),
         label='Site (ID)',
     )
@@ -124,6 +99,7 @@ class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Site (slug)',
     )
     group_id = NullableModelMultipleChoiceFilter(
+        name='group',
         queryset=RackGroup.objects.all(),
         label='Group (ID)',
     )
@@ -134,6 +110,7 @@ class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Group',
     )
     tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         label='Tenant (ID)',
     )
@@ -144,6 +121,7 @@ class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Tenant (slug)',
     )
     role_id = NullableModelMultipleChoiceFilter(
+        name='role',
         queryset=RackRole.objects.all(),
         label='Role (ID)',
     )
@@ -156,7 +134,7 @@ class RackFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
     class Meta:
         model = Rack
-        fields = ['facility_id', 'type', 'width', 'u_height', 'desc_units']
+        fields = ['u_height']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -174,10 +152,6 @@ class RackReservationFilter(django_filters.FilterSet):
         method='search',
         label='Search',
     )
-    rack_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=Rack.objects.all(),
-        label='Rack (ID)',
-    )
     site_id = django_filters.ModelMultipleChoiceFilter(
         name='rack__site',
         queryset=Site.objects.all(),
@@ -200,20 +174,15 @@ class RackReservationFilter(django_filters.FilterSet):
         to_field_name='slug',
         label='Group',
     )
-    user_id = django_filters.ModelMultipleChoiceFilter(
+    rack_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=User.objects.all(),
+        name='rack',
-        label='User (ID)',
+        queryset=Rack.objects.all(),
-    )
+        label='Rack (ID)',
-    user = django_filters.ModelMultipleChoiceFilter(
-        name='user',
-        queryset=User.objects.all(),
-        to_field_name='username',
-        label='User (name)',
     )
 
     class Meta:
         model = RackReservation
-        fields = ['created']
+        fields = ['rack', 'user']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -226,13 +195,6 @@ class RackReservationFilter(django_filters.FilterSet):
         )
 
 
-class ManufacturerFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = Manufacturer
-        fields = ['name', 'slug']
-
-
 class DeviceTypeFilter(CustomFieldFilterSet, django_filters.FilterSet):
     id__in = NumericInFilter(name='id', lookup_expr='in')
     q = django_filters.CharFilter(
@@ -240,6 +202,7 @@ class DeviceTypeFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Search',
     )
     manufacturer_id = django_filters.ModelMultipleChoiceFilter(
+        name='manufacturer',
         queryset=Manufacturer.objects.all(),
         label='Manufacturer (ID)',
     )
@@ -253,8 +216,7 @@ class DeviceTypeFilter(CustomFieldFilterSet, django_filters.FilterSet):
     class Meta:
         model = DeviceType
         fields = [
-            'model', 'slug', 'part_number', 'u_height', 'is_full_depth', 'is_console_server', 'is_pdu',
+            'model', 'part_number', 'u_height', 'is_console_server', 'is_pdu', 'is_network_device', 'subdevice_role',
-            'is_network_device', 'subdevice_role',
         ]
 
     def search(self, queryset, name, value):
@@ -268,122 +230,18 @@ class DeviceTypeFilter(CustomFieldFilterSet, django_filters.FilterSet):
         )
 
 
-class DeviceTypeComponentFilterSet(django_filters.FilterSet):
-    devicetype_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=DeviceType.objects.all(),
-        label='Device type (ID)',
-    )
-
-
-class ConsolePortTemplateFilter(DeviceTypeComponentFilterSet):
-
-    class Meta:
-        model = ConsolePortTemplate
-        fields = ['name']
-
-
-class ConsoleServerPortTemplateFilter(DeviceTypeComponentFilterSet):
-
-    class Meta:
-        model = ConsoleServerPortTemplate
-        fields = ['name']
-
-
-class PowerPortTemplateFilter(DeviceTypeComponentFilterSet):
-
-    class Meta:
-        model = PowerPortTemplate
-        fields = ['name']
-
-
-class PowerOutletTemplateFilter(DeviceTypeComponentFilterSet):
-
-    class Meta:
-        model = PowerOutletTemplate
-        fields = ['name']
-
-
-class InterfaceTemplateFilter(DeviceTypeComponentFilterSet):
-
-    class Meta:
-        model = InterfaceTemplate
-        fields = ['name', 'form_factor', 'mgmt_only']
-
-
-class DeviceBayTemplateFilter(DeviceTypeComponentFilterSet):
-
-    class Meta:
-        model = DeviceBayTemplate
-        fields = ['name']
-
-
-class DeviceRoleFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = DeviceRole
-        fields = ['name', 'slug', 'color']
-
-
-class PlatformFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = Platform
-        fields = ['name', 'slug']
-
-
 class DeviceFilter(CustomFieldFilterSet, django_filters.FilterSet):
     id__in = NumericInFilter(name='id', lookup_expr='in')
     q = django_filters.CharFilter(
         method='search',
         label='Search',
     )
-    manufacturer_id = django_filters.ModelMultipleChoiceFilter(
+    mac_address = django_filters.CharFilter(
-        name='device_type__manufacturer',
+        method='_mac_address',
-        queryset=Manufacturer.objects.all(),
+        label='MAC address',
-        label='Manufacturer (ID)',
-    )
-    manufacturer = django_filters.ModelMultipleChoiceFilter(
-        name='device_type__manufacturer__slug',
-        queryset=Manufacturer.objects.all(),
-        to_field_name='slug',
-        label='Manufacturer (slug)',
-    )
-    device_type_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=DeviceType.objects.all(),
-        label='Device type (ID)',
-    )
-    role_id = django_filters.ModelMultipleChoiceFilter(
-        name='device_role_id',
-        queryset=DeviceRole.objects.all(),
-        label='Role (ID)',
-    )
-    role = django_filters.ModelMultipleChoiceFilter(
-        name='device_role__slug',
-        queryset=DeviceRole.objects.all(),
-        to_field_name='slug',
-        label='Role (slug)',
-    )
-    tenant_id = NullableModelMultipleChoiceFilter(
-        queryset=Tenant.objects.all(),
-        label='Tenant (ID)',
-    )
-    tenant = NullableModelMultipleChoiceFilter(
-        name='tenant',
-        queryset=Tenant.objects.all(),
-        to_field_name='slug',
-        label='Tenant (slug)',
-    )
-    platform_id = NullableModelMultipleChoiceFilter(
-        queryset=Platform.objects.all(),
-        label='Platform (ID)',
-    )
-    platform = NullableModelMultipleChoiceFilter(
-        name='platform',
-        queryset=Platform.objects.all(),
-        to_field_name='slug',
-        label='Platform (slug)',
     )
     site_id = django_filters.ModelMultipleChoiceFilter(
+        name='site',
         queryset=Site.objects.all(),
         label='Site (ID)',
     )
@@ -403,18 +261,64 @@ class DeviceFilter(CustomFieldFilterSet, django_filters.FilterSet):
         queryset=Rack.objects.all(),
         label='Rack (ID)',
     )
+    role_id = django_filters.ModelMultipleChoiceFilter(
+        name='device_role',
+        queryset=DeviceRole.objects.all(),
+        label='Role (ID)',
+    )
+    role = django_filters.ModelMultipleChoiceFilter(
+        name='device_role__slug',
+        queryset=DeviceRole.objects.all(),
+        to_field_name='slug',
+        label='Role (slug)',
+    )
+    tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        label='Tenant (ID)',
+    )
+    tenant = NullableModelMultipleChoiceFilter(
+        name='tenant',
+        queryset=Tenant.objects.all(),
+        to_field_name='slug',
+        label='Tenant (slug)',
+    )
+    device_type_id = django_filters.ModelMultipleChoiceFilter(
+        name='device_type',
+        queryset=DeviceType.objects.all(),
+        label='Device type (ID)',
+    )
+    manufacturer_id = django_filters.ModelMultipleChoiceFilter(
+        name='device_type__manufacturer',
+        queryset=Manufacturer.objects.all(),
+        label='Manufacturer (ID)',
+    )
+    manufacturer = django_filters.ModelMultipleChoiceFilter(
+        name='device_type__manufacturer__slug',
+        queryset=Manufacturer.objects.all(),
+        to_field_name='slug',
+        label='Manufacturer (slug)',
+    )
     model = django_filters.ModelMultipleChoiceFilter(
         name='device_type__slug',
         queryset=DeviceType.objects.all(),
         to_field_name='slug',
         label='Device model (slug)',
     )
-    status = django_filters.MultipleChoiceFilter(
+    platform_id = NullableModelMultipleChoiceFilter(
-        choices=STATUS_CHOICES
+        name='platform',
+        queryset=Platform.objects.all(),
+        label='Platform (ID)',
     )
-    is_full_depth = django_filters.BooleanFilter(
+    platform = NullableModelMultipleChoiceFilter(
-        name='device_type__is_full_depth',
+        name='platform',
-        label='Is full depth',
+        queryset=Platform.objects.all(),
+        to_field_name='slug',
+        label='Platform (slug)',
+    )
+    status = django_filters.BooleanFilter(
+        name='status',
+        label='Status',
     )
     is_console_server = django_filters.BooleanFilter(
         name='device_type__is_console_server',
@@ -428,14 +332,6 @@ class DeviceFilter(CustomFieldFilterSet, django_filters.FilterSet):
         name='device_type__is_network_device',
         label='Is a network device',
     )
-    mac_address = django_filters.CharFilter(
-        method='_mac_address',
-        label='MAC address',
-    )
-    has_primary_ip = django_filters.BooleanFilter(
-        method='_has_primary_ip',
-        label='Has a primary IP',
-    )
 
     class Meta:
         model = Device
@@ -447,7 +343,7 @@ class DeviceFilter(CustomFieldFilterSet, django_filters.FilterSet):
         return queryset.filter(
             Q(name__icontains=value) |
             Q(serial__icontains=value.strip()) |
-            Q(inventory_items__serial__icontains=value.strip()) |
+            Q(modules__serial__icontains=value.strip()) |
             Q(asset_tag=value.strip()) |
             Q(comments__icontains=value)
         ).distinct()
@@ -461,53 +357,73 @@ class DeviceFilter(CustomFieldFilterSet, django_filters.FilterSet):
         except AddrFormatError:
             return queryset.none()
 
-    def _has_primary_ip(self, queryset, name, value):
-        if value:
-            return queryset.filter(
-                Q(primary_ip4__isnull=False) |
-                Q(primary_ip6__isnull=False)
-            )
-        else:
-            return queryset.exclude(
-                Q(primary_ip4__isnull=False) |
-                Q(primary_ip6__isnull=False)
-            )
 
-
+class ConsolePortFilter(django_filters.FilterSet):
-class DeviceComponentFilterSet(django_filters.FilterSet):
+    device_id = django_filters.ModelMultipleChoiceFilter(
-    device_id = django_filters.ModelChoiceFilter(
+        name='device',
         queryset=Device.objects.all(),
         label='Device (ID)',
     )
-    device = django_filters.ModelChoiceFilter(
+    device = django_filters.ModelMultipleChoiceFilter(
+        name='device',
         queryset=Device.objects.all(),
         to_field_name='name',
         label='Device (name)',
     )
 
-
-class ConsolePortFilter(DeviceComponentFilterSet):
-
     class Meta:
         model = ConsolePort
         fields = ['name']
 
 
-class ConsoleServerPortFilter(DeviceComponentFilterSet):
+class ConsoleServerPortFilter(django_filters.FilterSet):
+    device_id = django_filters.ModelMultipleChoiceFilter(
+        name='device',
+        queryset=Device.objects.all(),
+        label='Device (ID)',
+    )
+    device = django_filters.ModelMultipleChoiceFilter(
+        name='device',
+        queryset=Device.objects.all(),
+        to_field_name='name',
+        label='Device (name)',
+    )
 
     class Meta:
         model = ConsoleServerPort
         fields = ['name']
 
 
-class PowerPortFilter(DeviceComponentFilterSet):
+class PowerPortFilter(django_filters.FilterSet):
+    device_id = django_filters.ModelMultipleChoiceFilter(
+        name='device',
+        queryset=Device.objects.all(),
+        label='Device (ID)',
+    )
+    device = django_filters.ModelMultipleChoiceFilter(
+        name='device',
+        queryset=Device.objects.all(),
+        to_field_name='name',
+        label='Device (name)',
+    )
 
     class Meta:
         model = PowerPort
         fields = ['name']
 
 
-class PowerOutletFilter(DeviceComponentFilterSet):
+class PowerOutletFilter(django_filters.FilterSet):
+    device_id = django_filters.ModelMultipleChoiceFilter(
+        name='device',
+        queryset=Device.objects.all(),
+        label='Device (ID)',
+    )
+    device = django_filters.ModelMultipleChoiceFilter(
+        name='device',
+        queryset=Device.objects.all(),
+        to_field_name='name',
+        label='Device (name)',
+    )
 
     class Meta:
         model = PowerOutlet
@@ -515,29 +431,21 @@ class PowerOutletFilter(DeviceComponentFilterSet):
 
 
 class InterfaceFilter(django_filters.FilterSet):
-    """
+    device_id = django_filters.ModelMultipleChoiceFilter(
-    Not using DeviceComponentFilterSet for Interfaces because we need to glean the ordering logic from the parent
+        name='device',
-    Device's DeviceType.
+        queryset=Device.objects.all(),
-    """
-    device = django_filters.CharFilter(
-        method='filter_device',
-        name='name',
-        label='Device',
-    )
-    device_id = django_filters.NumberFilter(
-        method='filter_device',
-        name='pk',
         label='Device (ID)',
     )
+    device = django_filters.ModelMultipleChoiceFilter(
+        name='device',
+        queryset=Device.objects.all(),
+        to_field_name='name',
+        label='Device (name)',
+    )
     type = django_filters.CharFilter(
         method='filter_type',
         label='Interface type',
     )
-    lag_id = django_filters.ModelMultipleChoiceFilter(
-        name='lag',
-        queryset=Interface.objects.all(),
-        label='LAG interface (ID)',
-    )
     mac_address = django_filters.CharFilter(
         method='_mac_address',
         label='MAC address',
@@ -545,24 +453,17 @@ class InterfaceFilter(django_filters.FilterSet):
 
     class Meta:
         model = Interface
-        fields = ['name', 'form_factor', 'enabled', 'mtu', 'mgmt_only']
+        fields = ['name']
-
-    def filter_device(self, queryset, name, value):
-        try:
-            device = Device.objects.select_related('device_type').get(**{name: value})
-            ordering = device.device_type.interface_ordering
-            return queryset.filter(device=device).order_naturally(ordering)
-        except Device.DoesNotExist:
-            return queryset.none()
 
     def filter_type(self, queryset, name, value):
         value = value.strip().lower()
-        return {
+        if value == 'physical':
-            'physical': queryset.exclude(form_factor__in=NONCONNECTABLE_IFACE_TYPES),
+            return queryset.exclude(form_factor__in=VIRTUAL_IFACE_TYPES)
-            'virtual': queryset.filter(form_factor__in=VIRTUAL_IFACE_TYPES),
+        elif value == 'virtual':
-            'wireless': queryset.filter(form_factor__in=WIRELESS_IFACE_TYPES),
+            return queryset.filter(form_factor__in=VIRTUAL_IFACE_TYPES)
-            'lag': queryset.filter(form_factor=IFACE_FF_LAG),
+        elif value == 'lag':
-        }.get(value, queryset.none())
+            return queryset.filter(form_factor=IFACE_FF_LAG)
+        return queryset
 
     def _mac_address(self, queryset, name, value):
         value = value.strip()
@@ -574,34 +475,6 @@ class InterfaceFilter(django_filters.FilterSet):
             return queryset.none()
 
 
-class DeviceBayFilter(DeviceComponentFilterSet):
-
-    class Meta:
-        model = DeviceBay
-        fields = ['name']
-
-
-class InventoryItemFilter(DeviceComponentFilterSet):
-    parent_id = NullableModelMultipleChoiceFilter(
-        queryset=InventoryItem.objects.all(),
-        label='Parent inventory item (ID)',
-    )
-    manufacturer_id = django_filters.ModelMultipleChoiceFilter(
-        queryset=Manufacturer.objects.all(),
-        label='Manufacturer (ID)',
-    )
-    manufacturer = django_filters.ModelMultipleChoiceFilter(
-        name='manufacturer__slug',
-        queryset=Manufacturer.objects.all(),
-        to_field_name='slug',
-        label='Manufacturer (slug)',
-    )
-
-    class Meta:
-        model = InventoryItem
-        fields = ['name', 'part_id', 'serial', 'asset_tag', 'discovered']
-
-
 class ConsoleConnectionFilter(django_filters.FilterSet):
     site = django_filters.CharFilter(
         method='filter_site',
@@ -612,10 +485,6 @@ class ConsoleConnectionFilter(django_filters.FilterSet):
         label='Device',
     )
 
-    class Meta:
-        model = ConsolePort
-        fields = ['name', 'connection_status']
-
     def filter_site(self, queryset, name, value):
         if not value.strip():
             return queryset
@@ -640,10 +509,6 @@ class PowerConnectionFilter(django_filters.FilterSet):
         label='Device',
     )
 
-    class Meta:
-        model = PowerPort
-        fields = ['name', 'connection_status']
-
     def filter_site(self, queryset, name, value):
         if not value.strip():
             return queryset
@@ -668,10 +533,6 @@ class InterfaceConnectionFilter(django_filters.FilterSet):
         label='Device',
     )
 
-    class Meta:
-        model = InterfaceConnection
-        fields = ['connection_status']
-
     def filter_site(self, queryset, name, value):
         if not value.strip():
             return queryset

netbox/dcim/formfields.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from netaddr import EUI, AddrFormatError
 
 from django import forms

netbox/dcim/migrations/0033_rackreservation_rack_editable.py

@@ -1,21 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.10.6 on 2017-03-17 18:39
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0032_device_increase_name_length'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='rackreservation',
-            name='rack',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='reservations', to='dcim.Rack'),
-        ),
-    ]

netbox/dcim/migrations/0034_rename_module_to_inventoryitem.py

@@ -1,35 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.10.6 on 2017-03-21 14:55
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-import django.db.models.deletion
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0033_rackreservation_rack_editable'),
-    ]
-
-    operations = [
-        migrations.RenameModel(
-            old_name='Module',
-            new_name='InventoryItem',
-        ),
-        migrations.AlterField(
-            model_name='inventoryitem',
-            name='device',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='inventory_items', to='dcim.Device'),
-        ),
-        migrations.AlterField(
-            model_name='inventoryitem',
-            name='parent',
-            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='child_items', to='dcim.InventoryItem'),
-        ),
-        migrations.AlterField(
-            model_name='inventoryitem',
-            name='manufacturer',
-            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='inventory_items', to='dcim.Manufacturer'),
-        ),
-    ]

netbox/dcim/migrations/0035_device_expand_status_choices.py

@@ -1,27 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.10.7 on 2017-05-08 15:57
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0034_rename_module_to_inventoryitem'),
-    ]
-
-    # We convert the BooleanField to an IntegerField first as PostgreSQL does not provide a direct cast for boolean to
-    # smallint (attempting to convert directly yields the error "cannot cast type boolean to smallint").
-    operations = [
-        migrations.AlterField(
-            model_name='device',
-            name='status',
-            field=models.PositiveIntegerField(choices=[[1, b'Active'], [0, b'Offline'], [2, b'Planned'], [3, b'Staged'], [4, b'Failed'], [5, b'Inventory']], default=1, verbose_name=b'Status'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='status',
-            field=models.PositiveSmallIntegerField(choices=[[1, b'Active'], [0, b'Offline'], [2, b'Planned'], [3, b'Staged'], [4, b'Failed'], [5, b'Inventory']], default=1, verbose_name=b'Status'),
-        ),
-    ]

netbox/dcim/migrations/0036_add_ff_juniper_vcp.py

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11.1 on 2017-05-09 16:00
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0035_device_expand_status_choices'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='interface',
-            name='form_factor',
-            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual'], [200, b'Link Aggregation Group (LAG)']]], [b'Ethernet (fixed)', [[800, b'100BASE-TX (10/100ME)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Ethernet (modular)', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1200, b'SFP+ (10GE)'], [1300, b'XFP (10GE)'], [1310, b'XENPAK (10GE)'], [1320, b'X2 (10GE)'], [1350, b'SFP28 (25GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'FibreChannel', [[3010, b'SFP (1GFC)'], [3020, b'SFP (2GFC)'], [3040, b'SFP (4GFC)'], [3080, b'SFP+ (8GFC)'], [3160, b'SFP+ (16GFC)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus'], [5100, b'Cisco FlexStack'], [5150, b'Cisco FlexStack Plus'], [5200, b'Juniper VCP']]], [b'Other', [[32767, b'Other']]]], default=1200),
-        ),
-        migrations.AlterField(
-            model_name='interfacetemplate',
-            name='form_factor',
-            field=models.PositiveSmallIntegerField(choices=[[b'Virtual interfaces', [[0, b'Virtual'], [200, b'Link Aggregation Group (LAG)']]], [b'Ethernet (fixed)', [[800, b'100BASE-TX (10/100ME)'], [1000, b'1000BASE-T (1GE)'], [1150, b'10GBASE-T (10GE)']]], [b'Ethernet (modular)', [[1050, b'GBIC (1GE)'], [1100, b'SFP (1GE)'], [1200, b'SFP+ (10GE)'], [1300, b'XFP (10GE)'], [1310, b'XENPAK (10GE)'], [1320, b'X2 (10GE)'], [1350, b'SFP28 (25GE)'], [1400, b'QSFP+ (40GE)'], [1500, b'CFP (100GE)'], [1600, b'QSFP28 (100GE)']]], [b'FibreChannel', [[3010, b'SFP (1GFC)'], [3020, b'SFP (2GFC)'], [3040, b'SFP (4GFC)'], [3080, b'SFP+ (8GFC)'], [3160, b'SFP+ (16GFC)']]], [b'Serial', [[4000, b'T1 (1.544 Mbps)'], [4010, b'E1 (2.048 Mbps)'], [4040, b'T3 (45 Mbps)'], [4050, b'E3 (34 Mbps)'], [4050, b'E3 (34 Mbps)']]], [b'Stacking', [[5000, b'Cisco StackWise'], [5050, b'Cisco StackWise Plus'], [5100, b'Cisco FlexStack'], [5150, b'Cisco FlexStack Plus'], [5200, b'Juniper VCP']]], [b'Other', [[32767, b'Other']]]], default=1200),
-        ),
-    ]

netbox/dcim/migrations/0037_unicode_literals.py

@@ -1,209 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11 on 2017-05-24 15:34
-from __future__ import unicode_literals
-
-import dcim.fields
-import django.core.validators
-from django.db import migrations, models
-import django.db.models.deletion
-import utilities.fields
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0036_add_ff_juniper_vcp'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='consoleport',
-            name='connection_status',
-            field=models.NullBooleanField(choices=[[False, 'Planned'], [True, 'Connected']], default=True),
-        ),
-        migrations.AlterField(
-            model_name='consoleport',
-            name='cs_port',
-            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='connected_console', to='dcim.ConsoleServerPort', verbose_name='Console server port'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='asset_tag',
-            field=utilities.fields.NullableCharField(blank=True, help_text='A unique tag used to identify this device', max_length=50, null=True, unique=True, verbose_name='Asset tag'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='face',
-            field=models.PositiveSmallIntegerField(blank=True, choices=[[0, 'Front'], [1, 'Rear']], null=True, verbose_name='Rack face'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='position',
-            field=models.PositiveSmallIntegerField(blank=True, help_text='The lowest-numbered unit occupied by the device', null=True, validators=[django.core.validators.MinValueValidator(1)], verbose_name='Position (U)'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='primary_ip4',
-            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='primary_ip4_for', to='ipam.IPAddress', verbose_name='Primary IPv4'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='primary_ip6',
-            field=models.OneToOneField(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='primary_ip6_for', to='ipam.IPAddress', verbose_name='Primary IPv6'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='serial',
-            field=models.CharField(blank=True, max_length=50, verbose_name='Serial number'),
-        ),
-        migrations.AlterField(
-            model_name='device',
-            name='status',
-            field=models.PositiveSmallIntegerField(choices=[[1, 'Active'], [0, 'Offline'], [2, 'Planned'], [3, 'Staged'], [4, 'Failed'], [5, 'Inventory']], default=1, verbose_name='Status'),
-        ),
-        migrations.AlterField(
-            model_name='devicebay',
-            name='name',
-            field=models.CharField(max_length=50, verbose_name='Name'),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='interface_ordering',
-            field=models.PositiveSmallIntegerField(choices=[[1, 'Slot/position'], [2, 'Name (alphabetically)']], default=1),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='is_console_server',
-            field=models.BooleanField(default=False, help_text='This type of device has console server ports', verbose_name='Is a console server'),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='is_full_depth',
-            field=models.BooleanField(default=True, help_text='Device consumes both front and rear rack faces', verbose_name='Is full depth'),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='is_network_device',
-            field=models.BooleanField(default=True, help_text='This type of device has network interfaces', verbose_name='Is a network device'),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='is_pdu',
-            field=models.BooleanField(default=False, help_text='This type of device has power outlets', verbose_name='Is a PDU'),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='part_number',
-            field=models.CharField(blank=True, help_text='Discrete part number (optional)', max_length=50),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='subdevice_role',
-            field=models.NullBooleanField(choices=[(None, 'None'), (True, 'Parent'), (False, 'Child')], default=None, help_text='Parent devices house child devices in device bays. Select "None" if this device type is neither a parent nor a child.', verbose_name='Parent/child status'),
-        ),
-        migrations.AlterField(
-            model_name='devicetype',
-            name='u_height',
-            field=models.PositiveSmallIntegerField(default=1, verbose_name='Height (U)'),
-        ),
-        migrations.AlterField(
-            model_name='interface',
-            name='form_factor',
-            field=models.PositiveSmallIntegerField(choices=[['Virtual interfaces', [[0, 'Virtual'], [200, 'Link Aggregation Group (LAG)']]], ['Ethernet (fixed)', [[800, '100BASE-TX (10/100ME)'], [1000, '1000BASE-T (1GE)'], [1150, '10GBASE-T (10GE)']]], ['Ethernet (modular)', [[1050, 'GBIC (1GE)'], [1100, 'SFP (1GE)'], [1200, 'SFP+ (10GE)'], [1300, 'XFP (10GE)'], [1310, 'XENPAK (10GE)'], [1320, 'X2 (10GE)'], [1350, 'SFP28 (25GE)'], [1400, 'QSFP+ (40GE)'], [1500, 'CFP (100GE)'], [1600, 'QSFP28 (100GE)']]], ['FibreChannel', [[3010, 'SFP (1GFC)'], [3020, 'SFP (2GFC)'], [3040, 'SFP (4GFC)'], [3080, 'SFP+ (8GFC)'], [3160, 'SFP+ (16GFC)']]], ['Serial', [[4000, 'T1 (1.544 Mbps)'], [4010, 'E1 (2.048 Mbps)'], [4040, 'T3 (45 Mbps)'], [4050, 'E3 (34 Mbps)'], [4050, 'E3 (34 Mbps)']]], ['Stacking', [[5000, 'Cisco StackWise'], [5050, 'Cisco StackWise Plus'], [5100, 'Cisco FlexStack'], [5150, 'Cisco FlexStack Plus'], [5200, 'Juniper VCP']]], ['Other', [[32767, 'Other']]]], default=1200),
-        ),
-        migrations.AlterField(
-            model_name='interface',
-            name='lag',
-            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='member_interfaces', to='dcim.Interface', verbose_name='Parent LAG'),
-        ),
-        migrations.AlterField(
-            model_name='interface',
-            name='mac_address',
-            field=dcim.fields.MACAddressField(blank=True, null=True, verbose_name='MAC Address'),
-        ),
-        migrations.AlterField(
-            model_name='interface',
-            name='mgmt_only',
-            field=models.BooleanField(default=False, help_text='This interface is used only for out-of-band management', verbose_name='OOB Management'),
-        ),
-        migrations.AlterField(
-            model_name='interfaceconnection',
-            name='connection_status',
-            field=models.BooleanField(choices=[[False, 'Planned'], [True, 'Connected']], default=True, verbose_name='Status'),
-        ),
-        migrations.AlterField(
-            model_name='interfacetemplate',
-            name='form_factor',
-            field=models.PositiveSmallIntegerField(choices=[['Virtual interfaces', [[0, 'Virtual'], [200, 'Link Aggregation Group (LAG)']]], ['Ethernet (fixed)', [[800, '100BASE-TX (10/100ME)'], [1000, '1000BASE-T (1GE)'], [1150, '10GBASE-T (10GE)']]], ['Ethernet (modular)', [[1050, 'GBIC (1GE)'], [1100, 'SFP (1GE)'], [1200, 'SFP+ (10GE)'], [1300, 'XFP (10GE)'], [1310, 'XENPAK (10GE)'], [1320, 'X2 (10GE)'], [1350, 'SFP28 (25GE)'], [1400, 'QSFP+ (40GE)'], [1500, 'CFP (100GE)'], [1600, 'QSFP28 (100GE)']]], ['FibreChannel', [[3010, 'SFP (1GFC)'], [3020, 'SFP (2GFC)'], [3040, 'SFP (4GFC)'], [3080, 'SFP+ (8GFC)'], [3160, 'SFP+ (16GFC)']]], ['Serial', [[4000, 'T1 (1.544 Mbps)'], [4010, 'E1 (2.048 Mbps)'], [4040, 'T3 (45 Mbps)'], [4050, 'E3 (34 Mbps)'], [4050, 'E3 (34 Mbps)']]], ['Stacking', [[5000, 'Cisco StackWise'], [5050, 'Cisco StackWise Plus'], [5100, 'Cisco FlexStack'], [5150, 'Cisco FlexStack Plus'], [5200, 'Juniper VCP']]], ['Other', [[32767, 'Other']]]], default=1200),
-        ),
-        migrations.AlterField(
-            model_name='interfacetemplate',
-            name='mgmt_only',
-            field=models.BooleanField(default=False, verbose_name='Management only'),
-        ),
-        migrations.AlterField(
-            model_name='inventoryitem',
-            name='discovered',
-            field=models.BooleanField(default=False, verbose_name='Discovered'),
-        ),
-        migrations.AlterField(
-            model_name='inventoryitem',
-            name='name',
-            field=models.CharField(max_length=50, verbose_name='Name'),
-        ),
-        migrations.AlterField(
-            model_name='inventoryitem',
-            name='part_id',
-            field=models.CharField(blank=True, max_length=50, verbose_name='Part ID'),
-        ),
-        migrations.AlterField(
-            model_name='inventoryitem',
-            name='serial',
-            field=models.CharField(blank=True, max_length=50, verbose_name='Serial number'),
-        ),
-        migrations.AlterField(
-            model_name='platform',
-            name='rpc_client',
-            field=models.CharField(blank=True, choices=[['juniper-junos', 'Juniper Junos (NETCONF)'], ['cisco-ios', 'Cisco IOS (SSH)'], ['opengear', 'Opengear (SSH)']], max_length=30, verbose_name='RPC client'),
-        ),
-        migrations.AlterField(
-            model_name='powerport',
-            name='connection_status',
-            field=models.NullBooleanField(choices=[[False, 'Planned'], [True, 'Connected']], default=True),
-        ),
-        migrations.AlterField(
-            model_name='rack',
-            name='desc_units',
-            field=models.BooleanField(default=False, help_text='Units are numbered top-to-bottom', verbose_name='Descending units'),
-        ),
-        migrations.AlterField(
-            model_name='rack',
-            name='facility_id',
-            field=utilities.fields.NullableCharField(blank=True, max_length=30, null=True, verbose_name='Facility ID'),
-        ),
-        migrations.AlterField(
-            model_name='rack',
-            name='type',
-            field=models.PositiveSmallIntegerField(blank=True, choices=[(100, '2-post frame'), (200, '4-post frame'), (300, '4-post cabinet'), (1000, 'Wall-mounted frame'), (1100, 'Wall-mounted cabinet')], null=True, verbose_name='Type'),
-        ),
-        migrations.AlterField(
-            model_name='rack',
-            name='u_height',
-            field=models.PositiveSmallIntegerField(default=42, validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(100)], verbose_name='Height (U)'),
-        ),
-        migrations.AlterField(
-            model_name='rack',
-            name='width',
-            field=models.PositiveSmallIntegerField(choices=[(19, '19 inches'), (23, '23 inches')], default=19, help_text='Rail-to-rail width', verbose_name='Width'),
-        ),
-        migrations.AlterField(
-            model_name='site',
-            name='asn',
-            field=dcim.fields.ASNField(blank=True, null=True, verbose_name='ASN'),
-        ),
-        migrations.AlterField(
-            model_name='site',
-            name='contact_email',
-            field=models.EmailField(blank=True, max_length=254, verbose_name='Contact E-mail'),
-        ),
-    ]

netbox/dcim/migrations/0038_wireless_interfaces.py

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11.1 on 2017-06-16 21:38
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0037_unicode_literals'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='interface',
-            name='form_factor',
-            field=models.PositiveSmallIntegerField(choices=[['Virtual interfaces', [[0, 'Virtual'], [200, 'Link Aggregation Group (LAG)']]], ['Ethernet (fixed)', [[800, '100BASE-TX (10/100ME)'], [1000, '1000BASE-T (1GE)'], [1150, '10GBASE-T (10GE)']]], ['Ethernet (modular)', [[1050, 'GBIC (1GE)'], [1100, 'SFP (1GE)'], [1200, 'SFP+ (10GE)'], [1300, 'XFP (10GE)'], [1310, 'XENPAK (10GE)'], [1320, 'X2 (10GE)'], [1350, 'SFP28 (25GE)'], [1400, 'QSFP+ (40GE)'], [1500, 'CFP (100GE)'], [1600, 'QSFP28 (100GE)']]], ['Wireless', [[2600, 'IEEE 802.11a'], [2610, 'IEEE 802.11b/g'], [2620, 'IEEE 802.11n'], [2630, 'IEEE 802.11ac'], [2640, 'IEEE 802.11ad']]], ['FibreChannel', [[3010, 'SFP (1GFC)'], [3020, 'SFP (2GFC)'], [3040, 'SFP (4GFC)'], [3080, 'SFP+ (8GFC)'], [3160, 'SFP+ (16GFC)']]], ['Serial', [[4000, 'T1 (1.544 Mbps)'], [4010, 'E1 (2.048 Mbps)'], [4040, 'T3 (45 Mbps)'], [4050, 'E3 (34 Mbps)']]], ['Stacking', [[5000, 'Cisco StackWise'], [5050, 'Cisco StackWise Plus'], [5100, 'Cisco FlexStack'], [5150, 'Cisco FlexStack Plus'], [5200, 'Juniper VCP']]], ['Other', [[32767, 'Other']]]], default=1200),
-        ),
-        migrations.AlterField(
-            model_name='interfacetemplate',
-            name='form_factor',
-            field=models.PositiveSmallIntegerField(choices=[['Virtual interfaces', [[0, 'Virtual'], [200, 'Link Aggregation Group (LAG)']]], ['Ethernet (fixed)', [[800, '100BASE-TX (10/100ME)'], [1000, '1000BASE-T (1GE)'], [1150, '10GBASE-T (10GE)']]], ['Ethernet (modular)', [[1050, 'GBIC (1GE)'], [1100, 'SFP (1GE)'], [1200, 'SFP+ (10GE)'], [1300, 'XFP (10GE)'], [1310, 'XENPAK (10GE)'], [1320, 'X2 (10GE)'], [1350, 'SFP28 (25GE)'], [1400, 'QSFP+ (40GE)'], [1500, 'CFP (100GE)'], [1600, 'QSFP28 (100GE)']]], ['Wireless', [[2600, 'IEEE 802.11a'], [2610, 'IEEE 802.11b/g'], [2620, 'IEEE 802.11n'], [2630, 'IEEE 802.11ac'], [2640, 'IEEE 802.11ad']]], ['FibreChannel', [[3010, 'SFP (1GFC)'], [3020, 'SFP (2GFC)'], [3040, 'SFP (4GFC)'], [3080, 'SFP+ (8GFC)'], [3160, 'SFP+ (16GFC)']]], ['Serial', [[4000, 'T1 (1.544 Mbps)'], [4010, 'E1 (2.048 Mbps)'], [4040, 'T3 (45 Mbps)'], [4050, 'E3 (34 Mbps)']]], ['Stacking', [[5000, 'Cisco StackWise'], [5050, 'Cisco StackWise Plus'], [5100, 'Cisco FlexStack'], [5150, 'Cisco FlexStack Plus'], [5200, 'Juniper VCP']]], ['Other', [[32767, 'Other']]]], default=1200),
-        ),
-    ]

netbox/dcim/migrations/0039_interface_add_enabled_mtu.py

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11.1 on 2017-06-23 17:05
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0038_wireless_interfaces'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='interface',
-            name='enabled',
-            field=models.BooleanField(default=True),
-        ),
-        migrations.AddField(
-            model_name='interface',
-            name='mtu',
-            field=models.PositiveSmallIntegerField(blank=True, null=True, verbose_name='MTU'),
-        ),
-    ]

netbox/dcim/migrations/0040_inventoryitem_add_asset_tag_description.py

@@ -1,26 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11 on 2017-06-23 20:44
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-import utilities.fields
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('dcim', '0039_interface_add_enabled_mtu'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='inventoryitem',
-            name='asset_tag',
-            field=utilities.fields.NullableCharField(blank=True, help_text='A unique tag used to identify this item', max_length=50, null=True, unique=True, verbose_name='Asset tag'),
-        ),
-        migrations.AddField(
-            model_name='inventoryitem',
-            name='description',
-            field=models.CharField(blank=True, max_length=100),
-        ),
-    ]

netbox/dcim/models.py

@@ -1,4 +1,3 @@
-from __future__ import unicode_literals
 from collections import OrderedDict
 from itertools import count, groupby
 
@@ -10,24 +9,200 @@ from django.contrib.contenttypes.models import ContentType
 from django.contrib.contenttypes.fields import GenericRelation
 from django.contrib.postgres.fields import ArrayField
 from django.core.exceptions import ValidationError
+from django.core.urlresolvers import reverse
 from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
 from django.db.models import Count, Q, ObjectDoesNotExist
-from django.urls import reverse
 from django.utils.encoding import python_2_unicode_compatible
 
 from circuits.models import Circuit
-from extras.models import CustomFieldModel, CustomField, CustomFieldValue, ImageAttachment
+from extras.models import CustomFieldModel, CustomField, CustomFieldValue
 from extras.rpc import RPC_CLIENTS
 from tenancy.models import Tenant
 from utilities.fields import ColorField, NullableCharField
 from utilities.managers import NaturalOrderByManager
 from utilities.models import CreatedUpdatedModel
 from utilities.utils import csv_format
-from .constants import *
+
 from .fields import ASNField, MACAddressField
 
 
+RACK_TYPE_2POST = 100
+RACK_TYPE_4POST = 200
+RACK_TYPE_CABINET = 300
+RACK_TYPE_WALLFRAME = 1000
+RACK_TYPE_WALLCABINET = 1100
+RACK_TYPE_CHOICES = (
+    (RACK_TYPE_2POST, '2-post frame'),
+    (RACK_TYPE_4POST, '4-post frame'),
+    (RACK_TYPE_CABINET, '4-post cabinet'),
+    (RACK_TYPE_WALLFRAME, 'Wall-mounted frame'),
+    (RACK_TYPE_WALLCABINET, 'Wall-mounted cabinet'),
+)
+
+RACK_WIDTH_19IN = 19
+RACK_WIDTH_23IN = 23
+RACK_WIDTH_CHOICES = (
+    (RACK_WIDTH_19IN, '19 inches'),
+    (RACK_WIDTH_23IN, '23 inches'),
+)
+
+RACK_FACE_FRONT = 0
+RACK_FACE_REAR = 1
+RACK_FACE_CHOICES = [
+    [RACK_FACE_FRONT, 'Front'],
+    [RACK_FACE_REAR, 'Rear'],
+]
+
+SUBDEVICE_ROLE_PARENT = True
+SUBDEVICE_ROLE_CHILD = False
+SUBDEVICE_ROLE_CHOICES = (
+    (None, 'None'),
+    (SUBDEVICE_ROLE_PARENT, 'Parent'),
+    (SUBDEVICE_ROLE_CHILD, 'Child'),
+)
+
+IFACE_ORDERING_POSITION = 1
+IFACE_ORDERING_NAME = 2
+IFACE_ORDERING_CHOICES = [
+    [IFACE_ORDERING_POSITION, 'Slot/position'],
+    [IFACE_ORDERING_NAME, 'Name (alphabetically)']
+]
+
+# Virtual
+IFACE_FF_VIRTUAL = 0
+IFACE_FF_LAG = 200
+# Ethernet
+IFACE_FF_100ME_FIXED = 800
+IFACE_FF_1GE_FIXED = 1000
+IFACE_FF_1GE_GBIC = 1050
+IFACE_FF_1GE_SFP = 1100
+IFACE_FF_10GE_FIXED = 1150
+IFACE_FF_10GE_SFP_PLUS = 1200
+IFACE_FF_10GE_XFP = 1300
+IFACE_FF_10GE_XENPAK = 1310
+IFACE_FF_10GE_X2 = 1320
+IFACE_FF_25GE_SFP28 = 1350
+IFACE_FF_40GE_QSFP_PLUS = 1400
+IFACE_FF_100GE_CFP = 1500
+IFACE_FF_100GE_QSFP28 = 1600
+# Fibrechannel
+IFACE_FF_1GFC_SFP = 3010
+IFACE_FF_2GFC_SFP = 3020
+IFACE_FF_4GFC_SFP = 3040
+IFACE_FF_8GFC_SFP_PLUS = 3080
+IFACE_FF_16GFC_SFP_PLUS = 3160
+# Serial
+IFACE_FF_T1 = 4000
+IFACE_FF_E1 = 4010
+IFACE_FF_T3 = 4040
+IFACE_FF_E3 = 4050
+# Stacking
+IFACE_FF_STACKWISE = 5000
+IFACE_FF_STACKWISE_PLUS = 5050
+IFACE_FF_FLEXSTACK = 5100
+IFACE_FF_FLEXSTACK_PLUS = 5150
+# Other
+IFACE_FF_OTHER = 32767
+
+IFACE_FF_CHOICES = [
+    [
+        'Virtual interfaces',
+        [
+            [IFACE_FF_VIRTUAL, 'Virtual'],
+            [IFACE_FF_LAG, 'Link Aggregation Group (LAG)'],
+        ]
+    ],
+    [
+        'Ethernet (fixed)',
+        [
+            [IFACE_FF_100ME_FIXED, '100BASE-TX (10/100ME)'],
+            [IFACE_FF_1GE_FIXED, '1000BASE-T (1GE)'],
+            [IFACE_FF_10GE_FIXED, '10GBASE-T (10GE)'],
+        ]
+    ],
+    [
+        'Ethernet (modular)',
+        [
+            [IFACE_FF_1GE_GBIC, 'GBIC (1GE)'],
+            [IFACE_FF_1GE_SFP, 'SFP (1GE)'],
+            [IFACE_FF_10GE_SFP_PLUS, 'SFP+ (10GE)'],
+            [IFACE_FF_10GE_XFP, 'XFP (10GE)'],
+            [IFACE_FF_10GE_XENPAK, 'XENPAK (10GE)'],
+            [IFACE_FF_10GE_X2, 'X2 (10GE)'],
+            [IFACE_FF_25GE_SFP28, 'SFP28 (25GE)'],
+            [IFACE_FF_40GE_QSFP_PLUS, 'QSFP+ (40GE)'],
+            [IFACE_FF_100GE_CFP, 'CFP (100GE)'],
+            [IFACE_FF_100GE_QSFP28, 'QSFP28 (100GE)'],
+        ]
+    ],
+    [
+        'FibreChannel',
+        [
+            [IFACE_FF_1GFC_SFP, 'SFP (1GFC)'],
+            [IFACE_FF_2GFC_SFP, 'SFP (2GFC)'],
+            [IFACE_FF_4GFC_SFP, 'SFP (4GFC)'],
+            [IFACE_FF_8GFC_SFP_PLUS, 'SFP+ (8GFC)'],
+            [IFACE_FF_16GFC_SFP_PLUS, 'SFP+ (16GFC)'],
+        ]
+    ],
+    [
+        'Serial',
+        [
+            [IFACE_FF_T1, 'T1 (1.544 Mbps)'],
+            [IFACE_FF_E1, 'E1 (2.048 Mbps)'],
+            [IFACE_FF_T3, 'T3 (45 Mbps)'],
+            [IFACE_FF_E3, 'E3 (34 Mbps)'],
+            [IFACE_FF_E3, 'E3 (34 Mbps)'],
+        ]
+    ],
+    [
+        'Stacking',
+        [
+            [IFACE_FF_STACKWISE, 'Cisco StackWise'],
+            [IFACE_FF_STACKWISE_PLUS, 'Cisco StackWise Plus'],
+            [IFACE_FF_FLEXSTACK, 'Cisco FlexStack'],
+            [IFACE_FF_FLEXSTACK_PLUS, 'Cisco FlexStack Plus'],
+        ]
+    ],
+    [
+        'Other',
+        [
+            [IFACE_FF_OTHER, 'Other'],
+        ]
+    ],
+]
+
+VIRTUAL_IFACE_TYPES = [
+    IFACE_FF_VIRTUAL,
+    IFACE_FF_LAG,
+]
+
+STATUS_ACTIVE = True
+STATUS_OFFLINE = False
+STATUS_CHOICES = [
+    [STATUS_ACTIVE, 'Active'],
+    [STATUS_OFFLINE, 'Offline'],
+]
+
+CONNECTION_STATUS_PLANNED = False
+CONNECTION_STATUS_CONNECTED = True
+CONNECTION_STATUS_CHOICES = [
+    [CONNECTION_STATUS_PLANNED, 'Planned'],
+    [CONNECTION_STATUS_CONNECTED, 'Connected'],
+]
+
+# For mapping platform -> NC client
+RPC_CLIENT_JUNIPER_JUNOS = 'juniper-junos'
+RPC_CLIENT_CISCO_IOS = 'cisco-ios'
+RPC_CLIENT_OPENGEAR = 'opengear'
+RPC_CLIENT_CHOICES = [
+    [RPC_CLIENT_JUNIPER_JUNOS, 'Juniper Junos (NETCONF)'],
+    [RPC_CLIENT_CISCO_IOS, 'Cisco IOS (SSH)'],
+    [RPC_CLIENT_OPENGEAR, 'Opengear (SSH)'],
+]
+
+
 #
 # Regions
 #
@@ -37,9 +212,7 @@ class Region(MPTTModel):
     """
     Sites can be grouped within geographic Regions.
     """
-    parent = TreeForeignKey(
+    parent = TreeForeignKey('self', null=True, blank=True, related_name='children', db_index=True)
-        'self', null=True, blank=True, related_name='children', db_index=True, on_delete=models.CASCADE
-    )
     name = models.CharField(max_length=50, unique=True)
     slug = models.SlugField(unique=True)
 
@@ -82,14 +255,9 @@ class Site(CreatedUpdatedModel, CustomFieldModel):
     contact_email = models.EmailField(blank=True, verbose_name="Contact E-mail")
     comments = models.TextField(blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
-    images = GenericRelation(ImageAttachment)
 
     objects = SiteManager()
 
-    csv_headers = [
-        'name', 'slug', 'region', 'tenant', 'facility', 'asn', 'contact_name', 'contact_phone', 'contact_email',
-    ]
-
     class Meta:
         ordering = ['name']
 
@@ -146,7 +314,7 @@ class RackGroup(models.Model):
     """
     name = models.CharField(max_length=50)
     slug = models.SlugField()
-    site = models.ForeignKey('Site', related_name='rack_groups', on_delete=models.CASCADE)
+    site = models.ForeignKey('Site', related_name='rack_groups')
 
     class Meta:
         ordering = ['site', 'name']
@@ -156,7 +324,7 @@ class RackGroup(models.Model):
         ]
 
     def __str__(self):
-        return self.name
+        return u'{} - {}'.format(self.site.name, self.name)
 
     def get_absolute_url(self):
         return "{}?group_id={}".format(reverse('dcim:rack_list'), self.pk)
@@ -208,14 +376,9 @@ class Rack(CreatedUpdatedModel, CustomFieldModel):
                                      help_text='Units are numbered top-to-bottom')
     comments = models.TextField(blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
-    images = GenericRelation(ImageAttachment)
 
     objects = RackManager()
 
-    csv_headers = [
-        'site', 'group_name', 'name', 'facility_id', 'tenant', 'role', 'type', 'width', 'u_height', 'desc_units',
-    ]
-
     class Meta:
         ordering = ['site', 'name']
         unique_together = [
@@ -224,7 +387,7 @@ class Rack(CreatedUpdatedModel, CustomFieldModel):
         ]
 
     def __str__(self):
-        return self.display_name or super(Rack, self).__str__()
+        return self.display_name
 
     def get_absolute_url(self):
         return reverse('dcim:rack', args=[self.pk])
@@ -280,10 +443,8 @@ class Rack(CreatedUpdatedModel, CustomFieldModel):
     @property
     def display_name(self):
         if self.facility_id:
-            return "{} ({})".format(self.name, self.facility_id)
+            return u"{} ({})".format(self.name, self.facility_id)
-        elif self.name:
         return self.name
-        return ""
 
     def get_rack_units(self, face=RACK_FACE_FRONT, exclude=None, remove_redundant=False):
         """
@@ -373,7 +534,7 @@ class RackReservation(models.Model):
     """
     One or more reserved units within a Rack.
     """
-    rack = models.ForeignKey('Rack', related_name='reservations', on_delete=models.CASCADE)
+    rack = models.ForeignKey('Rack', related_name='reservations', editable=False, on_delete=models.CASCADE)
     units = ArrayField(models.PositiveSmallIntegerField())
     created = models.DateTimeField(auto_now_add=True)
     user = models.ForeignKey(User, editable=False, on_delete=models.PROTECT)
@@ -383,7 +544,7 @@ class RackReservation(models.Model):
         ordering = ['created']
 
     def __str__(self):
-        return "Reservation for rack {}".format(self.rack)
+        return u"Reservation for rack {}".format(self.rack)
 
     def clean(self):
 
@@ -393,7 +554,7 @@ class RackReservation(models.Model):
             invalid_units = [u for u in self.units if u not in self.rack.units]
             if invalid_units:
                 raise ValidationError({
-                    'units': "Invalid unit(s) for {}U rack: {}".format(
+                    'units': u"Invalid unit(s) for {}U rack: {}".format(
                         self.rack.u_height,
                         ', '.join([str(u) for u in invalid_units]),
                     ),
@@ -547,7 +708,7 @@ class DeviceType(models.Model, CustomFieldModel):
 
     @property
     def full_name(self):
-        return '{} {}'.format(self.manufacturer.name, self.model)
+        return u'{} {}'.format(self.manufacturer.name, self.model)
 
     @property
     def is_parent_device(self):
@@ -622,17 +783,17 @@ class PowerOutletTemplate(models.Model):
         return self.name
 
 
-class InterfaceQuerySet(models.QuerySet):
+class InterfaceManager(models.Manager):
 
     def order_naturally(self, method=IFACE_ORDERING_POSITION):
         """
-        Naturally order interfaces by their type and numeric position. The sort method must be one of the defined
+        Naturally order interfaces by their name and numeric position. The sort method must be one of the defined
         IFACE_ORDERING_CHOICES (typically indicated by a parent Device's DeviceType).
 
-        To order interfaces naturally, the `name` field is split into six distinct components: leading text (type),
+        To order interfaces naturally, the `name` field is split into five distinct components: leading text (name),
         slot, subslot, position, channel, and virtual circuit:
 
-            {type}{slot}/{subslot}/{position}:{channel}.{vc}
+            {name}{slot}/{subslot}/{position}:{channel}.{vc}
 
         Components absent from the interface name are ignored. For example, an interface named GigabitEthernet0/1 would
         be parsed as follows:
@@ -644,16 +805,16 @@ class InterfaceQuerySet(models.QuerySet):
             channel = None
             vc = 0
 
-        The original `name` field is taken as a whole to serve as a fallback in the event interfaces do not match any of
+        The chosen sorting method will determine which fields are ordered first in the query.
-        the prescribed fields.
         """
-        sql_col = '{}.name'.format(self.model._meta.db_table)
+        queryset = self.get_queryset()
+        sql_col = '{}.name'.format(queryset.model._meta.db_table)
         ordering = {
-            IFACE_ORDERING_POSITION: ('_slot', '_subslot', '_position', '_channel', '_vc', '_type', 'name'),
+            IFACE_ORDERING_POSITION: ('_slot', '_subslot', '_position', '_channel', '_vc', '_name'),
-            IFACE_ORDERING_NAME: ('_type', '_slot', '_subslot', '_position', '_channel', '_vc', 'name'),
+            IFACE_ORDERING_NAME: ('_name', '_slot', '_subslot', '_position', '_channel', '_vc'),
         }[method]
-        return self.extra(select={
+        return queryset.extra(select={
-            '_type': "SUBSTRING({} FROM '^([^0-9]+)')".format(sql_col),
+            '_name': "SUBSTRING({} FROM '^([^0-9]+)')".format(sql_col),
             '_slot': "CAST(SUBSTRING({} FROM '([0-9]+)\/[0-9]+\/[0-9]+(:[0-9]+)?(\.[0-9]+)?$') AS integer)".format(sql_col),
             '_subslot': "CAST(SUBSTRING({} FROM '([0-9]+)\/[0-9]+(:[0-9]+)?(\.[0-9]+)?$') AS integer)".format(sql_col),
             '_position': "CAST(SUBSTRING({} FROM '([0-9]+)(:[0-9]+)?(\.[0-9]+)?$') AS integer)".format(sql_col),
@@ -661,13 +822,6 @@ class InterfaceQuerySet(models.QuerySet):
             '_vc': "COALESCE(CAST(SUBSTRING({} FROM '\.([0-9]+)$') AS integer), 0)".format(sql_col),
         }).order_by(*ordering)
 
-    def connectable(self):
-        """
-        Return only physical interfaces which are capable of being connected to other interfaces (i.e. not virtual or
-        wireless).
-        """
-        return self.exclude(form_factor__in=NONCONNECTABLE_IFACE_TYPES)
-
 
 @python_2_unicode_compatible
 class InterfaceTemplate(models.Model):
@@ -679,7 +833,7 @@ class InterfaceTemplate(models.Model):
     form_factor = models.PositiveSmallIntegerField(choices=IFACE_FF_CHOICES, default=IFACE_FF_10GE_SFP_PLUS)
     mgmt_only = models.BooleanField(default=False, verbose_name='Management only')
 
-    objects = InterfaceQuerySet.as_manager()
+    objects = InterfaceManager()
 
     class Meta:
         ordering = ['device_type', 'name']
@@ -762,11 +916,11 @@ class Device(CreatedUpdatedModel, CustomFieldModel):
     A Device represents a piece of physical hardware mounted within a Rack. Each Device is assigned a DeviceType,
     DeviceRole, and (optionally) a Platform. Device names are not required, however if one is set it must be unique.
 
-    Each Device must be assigned to a site, and optionally to a rack within that site. Associating a device with a
+    Each Device must be assigned to a Rack, although associating it with a particular rack face or unit is optional (for
-    particular rack face or unit is optional (for example, vertically mounted PDUs do not consume rack units).
+    example, vertically mounted PDUs do not consume rack units).
 
-    When a new Device is created, console/power/interface/device bay components are created along with it as dictated
+    When a new Device is created, console/power/interface components are created along with it as dictated by the
-    by the component templates assigned to its DeviceType. Components can also be added, modified, or deleted after the
+    component templates assigned to its DeviceType. Components can also be added, modified, or deleted after the
     creation of a Device.
     """
     device_type = models.ForeignKey('DeviceType', related_name='instances', on_delete=models.PROTECT)
@@ -775,43 +929,30 @@ class Device(CreatedUpdatedModel, CustomFieldModel):
     platform = models.ForeignKey('Platform', related_name='devices', blank=True, null=True, on_delete=models.SET_NULL)
     name = NullableCharField(max_length=64, blank=True, null=True, unique=True)
     serial = models.CharField(max_length=50, blank=True, verbose_name='Serial number')
-    asset_tag = NullableCharField(
+    asset_tag = NullableCharField(max_length=50, blank=True, null=True, unique=True, verbose_name='Asset tag',
-        max_length=50, blank=True, null=True, unique=True, verbose_name='Asset tag',
+                                  help_text='A unique tag used to identify this device')
-        help_text='A unique tag used to identify this device'
-    )
     site = models.ForeignKey('Site', related_name='devices', on_delete=models.PROTECT)
     rack = models.ForeignKey('Rack', related_name='devices', blank=True, null=True, on_delete=models.PROTECT)
-    position = models.PositiveSmallIntegerField(
+    position = models.PositiveSmallIntegerField(blank=True, null=True, validators=[MinValueValidator(1)],
-        blank=True, null=True, validators=[MinValueValidator(1)], verbose_name='Position (U)',
+                                                verbose_name='Position (U)',
-        help_text='The lowest-numbered unit occupied by the device'
+                                                help_text='The lowest-numbered unit occupied by the device')
-    )
     face = models.PositiveSmallIntegerField(blank=True, null=True, choices=RACK_FACE_CHOICES, verbose_name='Rack face')
-    status = models.PositiveSmallIntegerField(choices=STATUS_CHOICES, default=STATUS_ACTIVE, verbose_name='Status')
+    status = models.BooleanField(choices=STATUS_CHOICES, default=STATUS_ACTIVE, verbose_name='Status')
-    primary_ip4 = models.OneToOneField(
+    primary_ip4 = models.OneToOneField('ipam.IPAddress', related_name='primary_ip4_for', on_delete=models.SET_NULL,
-        'ipam.IPAddress', related_name='primary_ip4_for', on_delete=models.SET_NULL, blank=True, null=True,
+                                       blank=True, null=True, verbose_name='Primary IPv4')
-        verbose_name='Primary IPv4'
+    primary_ip6 = models.OneToOneField('ipam.IPAddress', related_name='primary_ip6_for', on_delete=models.SET_NULL,
-    )
+                                       blank=True, null=True, verbose_name='Primary IPv6')
-    primary_ip6 = models.OneToOneField(
-        'ipam.IPAddress', related_name='primary_ip6_for', on_delete=models.SET_NULL, blank=True, null=True,
-        verbose_name='Primary IPv6'
-    )
     comments = models.TextField(blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
-    images = GenericRelation(ImageAttachment)
 
     objects = DeviceManager()
 
-    csv_headers = [
-        'name', 'device_role', 'tenant', 'manufacturer', 'model_name', 'platform', 'serial', 'asset_tag', 'status',
-        'site', 'rack_group', 'rack_name', 'position', 'face',
-    ]
-
     class Meta:
         ordering = ['name']
         unique_together = ['rack', 'position', 'face']
 
     def __str__(self):
-        return self.display_name or super(Device, self).__str__()
+        return self.display_name
 
     def get_absolute_url(self):
         return reverse('dcim:device', args=[self.pk])
@@ -919,9 +1060,7 @@ class Device(CreatedUpdatedModel, CustomFieldModel):
             self.platform.name if self.platform else None,
             self.serial,
             self.asset_tag,
-            self.get_status_display(),
             self.site.name,
-            self.rack.group.name if self.rack and self.rack.group else None,
             self.rack.name if self.rack else None,
             self.position,
             self.get_face_display(),
@@ -931,9 +1070,12 @@ class Device(CreatedUpdatedModel, CustomFieldModel):
     def display_name(self):
         if self.name:
             return self.name
-        elif hasattr(self, 'device_type'):
+        elif self.position:
-            return "{}".format(self.device_type)
+            return u"{} ({} U{})".format(self.device_type, self.rack.name, self.position)
-        return ""
+        elif self.rack:
+            return u"{} ({})".format(self.device_type, self.rack.name)
+        else:
+            return u"{} ({})".format(self.device_type, self.site.name)
 
     @property
     def identifier(self):
@@ -961,9 +1103,6 @@ class Device(CreatedUpdatedModel, CustomFieldModel):
         """
         return Device.objects.filter(parent_bay__device=self.pk)
 
-    def get_status_class(self):
-        return DEVICE_STATUS_CLASSES[self.status]
-
     def get_rpc_client(self):
         """
         Return the appropriate RPC (e.g. NETCONF, ssh, etc.) client for this device's platform, if one is defined.
@@ -988,8 +1127,6 @@ class ConsolePort(models.Model):
                                    verbose_name='Console server port', blank=True, null=True)
     connection_status = models.NullBooleanField(choices=CONNECTION_STATUS_CHOICES, default=CONNECTION_STATUS_CONNECTED)
 
-    csv_headers = ['console_server', 'cs_port', 'device', 'console_port', 'connection_status']
-
     class Meta:
         ordering = ['device', 'name']
         unique_together = ['device', 'name']
@@ -1059,8 +1196,6 @@ class PowerPort(models.Model):
                                         blank=True, null=True)
     connection_status = models.NullBooleanField(choices=CONNECTION_STATUS_CHOICES, default=CONNECTION_STATUS_CONNECTED)
 
-    csv_headers = ['pdu', 'power_outlet', 'device', 'power_port', 'connection_status']
-
     class Meta:
         ordering = ['device', 'name']
         unique_together = ['device', 'name']
@@ -1120,27 +1255,16 @@ class Interface(models.Model):
     of an InterfaceConnection.
     """
     device = models.ForeignKey('Device', related_name='interfaces', on_delete=models.CASCADE)
-    lag = models.ForeignKey(
+    lag = models.ForeignKey('self', related_name='member_interfaces', null=True, blank=True, on_delete=models.SET_NULL,
-        'self',
+                            verbose_name='Parent LAG')
-        models.SET_NULL,
-        related_name='member_interfaces',
-        null=True,
-        blank=True,
-        verbose_name='Parent LAG'
-    )
     name = models.CharField(max_length=30)
     form_factor = models.PositiveSmallIntegerField(choices=IFACE_FF_CHOICES, default=IFACE_FF_10GE_SFP_PLUS)
-    enabled = models.BooleanField(default=True)
     mac_address = MACAddressField(null=True, blank=True, verbose_name='MAC Address')
-    mtu = models.PositiveSmallIntegerField(blank=True, null=True, verbose_name='MTU')
+    mgmt_only = models.BooleanField(default=False, verbose_name='OOB Management',
-    mgmt_only = models.BooleanField(
+                                    help_text="This interface is used only for out-of-band management")
-        default=False,
-        verbose_name='OOB Management',
-        help_text="This interface is used only for out-of-band management"
-    )
     description = models.CharField(max_length=100, blank=True)
 
-    objects = InterfaceQuerySet.as_manager()
+    objects = InterfaceManager()
 
     class Meta:
         ordering = ['device', 'name']
@@ -1152,31 +1276,31 @@ class Interface(models.Model):
     def clean(self):
 
         # Virtual interfaces cannot be connected
-        if self.form_factor in NONCONNECTABLE_IFACE_TYPES and self.is_connected:
+        if self.form_factor in VIRTUAL_IFACE_TYPES and self.is_connected:
             raise ValidationError({
-                'form_factor': "Virtual and wireless interfaces cannot be connected to another interface or circuit. "
+                'form_factor': "Virtual interfaces cannot be connected to another interface or circuit. Disconnect the "
-                               "Disconnect the interface or choose a suitable form factor."
+                               "interface or choose a physical form factor."
             })
 
         # An interface's LAG must belong to the same device
         if self.lag and self.lag.device != self.device:
             raise ValidationError({
-                'lag': "The selected LAG interface ({}) belongs to a different device ({}).".format(
+                'lag': u"The selected LAG interface ({}) belongs to a different device ({}).".format(
                     self.lag.name, self.lag.device.name
                 )
             })
 
         # A virtual interface cannot have a parent LAG
-        if self.form_factor in NONCONNECTABLE_IFACE_TYPES and self.lag is not None:
+        if self.form_factor in VIRTUAL_IFACE_TYPES and self.lag is not None:
             raise ValidationError({
-                'lag': "{} interfaces cannot have a parent LAG interface.".format(self.get_form_factor_display())
+                'lag': u"{} interfaces cannot have a parent LAG interface.".format(self.get_form_factor_display())
             })
 
         # Only a LAG can have LAG members
         if self.form_factor != IFACE_FF_LAG and self.member_interfaces.exists():
             raise ValidationError({
                 'form_factor': "Cannot change interface form factor; it has LAG members ({}).".format(
-                    ", ".join([iface.name for iface in self.member_interfaces.all()])
+                    u", ".join([iface.name for iface in self.member_interfaces.all()])
                 )
             })
 
@@ -1184,10 +1308,6 @@ class Interface(models.Model):
     def is_virtual(self):
         return self.form_factor in VIRTUAL_IFACE_TYPES
 
-    @property
-    def is_wireless(self):
-        return self.form_factor in WIRELESS_IFACE_TYPES
-
     @property
     def is_lag(self):
         return self.form_factor == IFACE_FF_LAG
@@ -1237,16 +1357,11 @@ class InterfaceConnection(models.Model):
     connection_status = models.BooleanField(choices=CONNECTION_STATUS_CHOICES, default=CONNECTION_STATUS_CONNECTED,
                                             verbose_name='Status')
 
-    csv_headers = ['device_a', 'interface_a', 'device_b', 'interface_b', 'connection_status']
-
     def clean(self):
-        try:
         if self.interface_a == self.interface_b:
             raise ValidationError({
                 'interface_b': "Cannot connect an interface to itself."
             })
-        except ObjectDoesNotExist:
-            pass
 
     # Used for connections export
     def to_csv(self):
@@ -1278,7 +1393,7 @@ class DeviceBay(models.Model):
         unique_together = ['device', 'name']
 
     def __str__(self):
-        return '{} - {}'.format(self.device.name, self.name)
+        return u'{} - {}'.format(self.device.name, self.name)
 
     def clean(self):
 
@@ -1294,29 +1409,23 @@ class DeviceBay(models.Model):
 
 
 #
-# Inventory items
+# Modules
 #
 
 @python_2_unicode_compatible
-class InventoryItem(models.Model):
+class Module(models.Model):
     """
-    An InventoryItem represents a serialized piece of hardware within a Device, such as a line card or power supply.
+    A Module represents a piece of hardware within a Device, such as a line card or power supply. Modules are used only
-    InventoryItems are used only for inventory purposes.
+    for inventory purposes.
     """
-    device = models.ForeignKey('Device', related_name='inventory_items', on_delete=models.CASCADE)
+    device = models.ForeignKey('Device', related_name='modules', on_delete=models.CASCADE)
-    parent = models.ForeignKey('self', related_name='child_items', blank=True, null=True, on_delete=models.CASCADE)
+    parent = models.ForeignKey('self', related_name='submodules', blank=True, null=True, on_delete=models.CASCADE)
     name = models.CharField(max_length=50, verbose_name='Name')
-    manufacturer = models.ForeignKey(
+    manufacturer = models.ForeignKey('Manufacturer', related_name='modules', blank=True, null=True,
-        'Manufacturer', models.PROTECT, related_name='inventory_items', blank=True, null=True
+                                     on_delete=models.PROTECT)
-    )
     part_id = models.CharField(max_length=50, verbose_name='Part ID', blank=True)
     serial = models.CharField(max_length=50, verbose_name='Serial number', blank=True)
-    asset_tag = NullableCharField(
-        max_length=50, blank=True, null=True, unique=True, verbose_name='Asset tag',
-        help_text='A unique tag used to identify this item'
-    )
     discovered = models.BooleanField(default=False, verbose_name='Discovered')
-    description = models.CharField(max_length=100, blank=True)
 
     class Meta:
         ordering = ['device__id', 'parent__id', 'name']

netbox/dcim/tables.py

@@ -1,9 +1,8 @@
-from __future__ import unicode_literals
-
 import django_tables2 as tables
 from django_tables2.utils import Accessor
 
-from utilities.tables import BaseTable, SearchTable, ToggleColumn
+from utilities.tables import BaseTable, ToggleColumn
+
 from .models import (
     ConsolePort, ConsolePortTemplate, ConsoleServerPortTemplate, Device, DeviceBayTemplate, DeviceRole, DeviceType,
     Interface, InterfaceTemplate, Manufacturer, Platform, PowerOutletTemplate, PowerPort, PowerPortTemplate, Rack,
@@ -93,8 +92,12 @@ DEVICE_ROLE = """
 <label class="label" style="background-color: #{{ record.device_role.color }}">{{ value }}</label>
 """
 
-DEVICE_STATUS = """
+STATUS_ICON = """
-<span class="label label-{{ record.get_status_class }}">{{ record.get_status_display }}</span>
+{% if record.status %}
+    <span class="glyphicon glyphicon-ok-sign text-success" title="Active" aria-hidden="true"></span>
+{% else %}
+    <span class="glyphicon glyphicon-minus-sign text-danger" title="Offline" aria-hidden="true"></span>
+{% endif %}
 """
 
 DEVICE_PRIMARY_IP = """
@@ -139,9 +142,11 @@ class RegionTable(BaseTable):
 
 class SiteTable(BaseTable):
     pk = ToggleColumn()
-    name = tables.LinkColumn()
+    name = tables.LinkColumn('dcim:site', args=[Accessor('slug')], verbose_name='Name')
-    region = tables.TemplateColumn(template_code=SITE_REGION_LINK)
+    facility = tables.Column(verbose_name='Facility')
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
+    region = tables.TemplateColumn(template_code=SITE_REGION_LINK, verbose_name='Region')
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
+    asn = tables.Column(verbose_name='ASN')
     rack_count = tables.Column(accessor=Accessor('count_racks'), orderable=False, verbose_name='Racks')
     device_count = tables.Column(accessor=Accessor('count_devices'), orderable=False, verbose_name='Devices')
     prefix_count = tables.Column(accessor=Accessor('count_prefixes'), orderable=False, verbose_name='Prefixes')
@@ -156,16 +161,6 @@ class SiteTable(BaseTable):
         )
 
 
-class SiteSearchTable(SearchTable):
-    name = tables.LinkColumn()
-    region = tables.TemplateColumn(template_code=SITE_REGION_LINK)
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
-
-    class Meta(SearchTable.Meta):
-        model = Site
-        fields = ('name', 'facility', 'region', 'tenant', 'asn')
-
-
 #
 # Rack groups
 #
@@ -208,33 +203,20 @@ class RackRoleTable(BaseTable):
 
 class RackTable(BaseTable):
     pk = ToggleColumn()
-    name = tables.LinkColumn()
+    name = tables.LinkColumn('dcim:rack', args=[Accessor('pk')], verbose_name='Name')
-    site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')])
+    site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')], verbose_name='Site')
     group = tables.Column(accessor=Accessor('group.name'), verbose_name='Group')
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
+    facility_id = tables.Column(verbose_name='Facility ID')
-    role = tables.TemplateColumn(RACK_ROLE)
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
+    role = tables.TemplateColumn(RACK_ROLE, verbose_name='Role')
     u_height = tables.TemplateColumn("{{ record.u_height }}U", verbose_name='Height')
-    devices = tables.Column(accessor=Accessor('device_count'))
+    devices = tables.Column(accessor=Accessor('device_count'), verbose_name='Devices')
     get_utilization = tables.TemplateColumn(UTILIZATION_GRAPH, orderable=False, verbose_name='Utilization')
 
     class Meta(BaseTable.Meta):
         model = Rack
-        fields = (
+        fields = ('pk', 'name', 'site', 'group', 'facility_id', 'tenant', 'role', 'u_height', 'devices',
-            'pk', 'name', 'site', 'group', 'facility_id', 'tenant', 'role', 'u_height', 'devices', 'get_utilization'
+                  'get_utilization')
-        )
-
-
-class RackSearchTable(SearchTable):
-    name = tables.LinkColumn()
-    site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')])
-    group = tables.Column(accessor=Accessor('group.name'), verbose_name='Group')
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
-    role = tables.TemplateColumn(RACK_ROLE)
-    u_height = tables.TemplateColumn("{{ record.u_height }}U", verbose_name='Height')
-
-    class Meta(SearchTable.Meta):
-        model = Rack
-        fields = ('name', 'site', 'group', 'facility_id', 'tenant', 'role', 'u_height')
 
 
 class RackImportTable(BaseTable):
@@ -247,7 +229,7 @@ class RackImportTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = Rack
-        fields = ('name', 'site', 'group', 'facility_id', 'tenant', 'u_height')
+        fields = ('site', 'group', 'name', 'facility_id', 'tenant', 'u_height')
 
 
 #
@@ -290,7 +272,9 @@ class ManufacturerTable(BaseTable):
 
 class DeviceTypeTable(BaseTable):
     pk = ToggleColumn()
+    manufacturer = tables.Column(verbose_name='Manufacturer')
     model = tables.LinkColumn('dcim:devicetype', args=[Accessor('pk')], verbose_name='Device Type')
+    part_number = tables.Column(verbose_name='Part Number')
     is_full_depth = tables.BooleanColumn(verbose_name='Full Depth')
     is_console_server = tables.BooleanColumn(verbose_name='CS')
     is_pdu = tables.BooleanColumn(verbose_name='PDU')
@@ -306,22 +290,6 @@ class DeviceTypeTable(BaseTable):
         )
 
 
-class DeviceTypeSearchTable(SearchTable):
-    model = tables.LinkColumn('dcim:devicetype', args=[Accessor('pk')], verbose_name='Device Type')
-    is_full_depth = tables.BooleanColumn(verbose_name='Full Depth')
-    is_console_server = tables.BooleanColumn(verbose_name='CS')
-    is_pdu = tables.BooleanColumn(verbose_name='PDU')
-    is_network_device = tables.BooleanColumn(verbose_name='Net')
-    subdevice_role = tables.TemplateColumn(SUBDEVICE_ROLE_TEMPLATE, verbose_name='Subdevice Role')
-
-    class Meta(SearchTable.Meta):
-        model = DeviceType
-        fields = (
-            'model', 'manufacturer', 'part_number', 'u_height', 'is_full_depth', 'is_console_server', 'is_pdu',
-            'is_network_device', 'subdevice_role',
-        )
-
-
 #
 # Device type components
 #
@@ -368,11 +336,10 @@ class PowerOutletTemplateTable(BaseTable):
 
 class InterfaceTemplateTable(BaseTable):
     pk = ToggleColumn()
-    mgmt_only = tables.TemplateColumn("{% if value %}OOB Management{% endif %}")
 
     class Meta(BaseTable.Meta):
         model = InterfaceTemplate
-        fields = ('pk', 'name', 'mgmt_only', 'form_factor')
+        fields = ('pk', 'name', 'form_factor')
         empty_text = "None"
         show_header = False
 
@@ -414,13 +381,12 @@ class PlatformTable(BaseTable):
     name = tables.LinkColumn(verbose_name='Name')
     device_count = tables.Column(verbose_name='Devices')
     slug = tables.Column(verbose_name='Slug')
-    rpc_client = tables.Column(accessor='get_rpc_client_display', orderable=False, verbose_name='RPC Client')
     actions = tables.TemplateColumn(template_code=PLATFORM_ACTIONS, attrs={'td': {'class': 'text-right'}},
                                     verbose_name='')
 
     class Meta(BaseTable.Meta):
         model = Platform
-        fields = ('pk', 'name', 'device_count', 'slug', 'rpc_client', 'actions')
+        fields = ('pk', 'name', 'device_count', 'slug', 'actions')
 
 
 #
@@ -429,45 +395,24 @@ class PlatformTable(BaseTable):
 
 class DeviceTable(BaseTable):
     pk = ToggleColumn()
-    name = tables.TemplateColumn(template_code=DEVICE_LINK)
+    status = tables.TemplateColumn(template_code=STATUS_ICON, verbose_name='')
-    status = tables.TemplateColumn(template_code=DEVICE_STATUS, verbose_name='Status')
+    name = tables.TemplateColumn(template_code=DEVICE_LINK, verbose_name='Name')
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
+    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
-    site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')])
+    site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')], verbose_name='Site')
-    rack = tables.LinkColumn('dcim:rack', args=[Accessor('rack.pk')])
+    rack = tables.LinkColumn('dcim:rack', args=[Accessor('rack.pk')], verbose_name='Rack')
     device_role = tables.TemplateColumn(DEVICE_ROLE, verbose_name='Role')
-    device_type = tables.LinkColumn(
+    device_type = tables.LinkColumn('dcim:devicetype', args=[Accessor('device_type.pk')], verbose_name='Type',
-        'dcim:devicetype', args=[Accessor('device_type.pk')], verbose_name='Type',
+                                    text=lambda record: record.device_type.full_name)
-        text=lambda record: record.device_type.full_name
+    primary_ip = tables.TemplateColumn(orderable=False, verbose_name='IP Address',
-    )
+                                       template_code=DEVICE_PRIMARY_IP)
-    primary_ip = tables.TemplateColumn(
-        orderable=False, verbose_name='IP Address', template_code=DEVICE_PRIMARY_IP
-    )
 
     class Meta(BaseTable.Meta):
         model = Device
         fields = ('pk', 'name', 'status', 'tenant', 'site', 'rack', 'device_role', 'device_type', 'primary_ip')
 
 
-class DeviceSearchTable(SearchTable):
-    name = tables.TemplateColumn(template_code=DEVICE_LINK)
-    status = tables.TemplateColumn(template_code=DEVICE_STATUS, verbose_name='Status')
-    tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')])
-    site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')])
-    rack = tables.LinkColumn('dcim:rack', args=[Accessor('rack.pk')])
-    device_role = tables.TemplateColumn(DEVICE_ROLE, verbose_name='Role')
-    device_type = tables.LinkColumn(
-        'dcim:devicetype', args=[Accessor('device_type.pk')], verbose_name='Type',
-        text=lambda record: record.device_type.full_name
-    )
-
-    class Meta(SearchTable.Meta):
-        model = Device
-        fields = ('name', 'status', 'tenant', 'site', 'rack', 'device_role', 'device_type')
-
-
 class DeviceImportTable(BaseTable):
     name = tables.TemplateColumn(template_code=DEVICE_LINK, verbose_name='Name')
-    status = tables.TemplateColumn(template_code=DEVICE_STATUS, verbose_name='Status')
     tenant = tables.LinkColumn('tenancy:tenant', args=[Accessor('tenant.slug')], verbose_name='Tenant')
     site = tables.LinkColumn('dcim:site', args=[Accessor('site.slug')], verbose_name='Site')
     rack = tables.LinkColumn('dcim:rack', args=[Accessor('rack.pk')], verbose_name='Rack')
@@ -477,7 +422,7 @@ class DeviceImportTable(BaseTable):
 
     class Meta(BaseTable.Meta):
         model = Device
-        fields = ('name', 'status', 'tenant', 'site', 'rack', 'position', 'device_role', 'device_type')
+        fields = ('name', 'tenant', 'site', 'rack', 'position', 'device_role', 'device_type')
         empty_text = False
 
 

netbox/dcim/tests/test_apis.py

@@ -0,0 +1,676 @@
+import json
+from rest_framework import status
+from rest_framework.test import APITestCase
+
+from django.conf import settings
+
+
+class SiteTest(APITestCase):
+
+    fixtures = [
+        'dcim',
+        'ipam',
+        'extras',
+    ]
+
+    standard_fields = [
+        'id',
+        'name',
+        'slug',
+        'region',
+        'tenant',
+        'facility',
+        'asn',
+        'physical_address',
+        'shipping_address',
+        'contact_name',
+        'contact_phone',
+        'contact_email',
+        'comments',
+        'custom_fields',
+        'count_prefixes',
+        'count_vlans',
+        'count_racks',
+        'count_devices',
+        'count_circuits'
+    ]
+
+    nested_fields = [
+        'id',
+        'name',
+        'slug'
+    ]
+
+    rack_fields = [
+        'id',
+        'name',
+        'facility_id',
+        'display_name',
+        'site',
+        'group',
+        'tenant',
+        'role',
+        'type',
+        'width',
+        'u_height',
+        'desc_units',
+        'comments',
+        'custom_fields',
+    ]
+
+    graph_fields = [
+        'name',
+        'embed_url',
+        'embed_link',
+    ]
+
+    def test_get_list(self, endpoint='/{}api/dcim/sites/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/sites/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )
+
+    def test_get_site_list_rack(self, endpoint='/{}api/dcim/sites/1/racks/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in json.loads(response.content.decode('utf-8')):
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.rack_fields),
+            )
+            # Check Nested Serializer.
+            self.assertEqual(
+                sorted(i.get('site').keys()),
+                sorted(self.nested_fields),
+            )
+
+    def test_get_site_list_graphs(self, endpoint='/{}api/dcim/sites/1/graphs/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in json.loads(response.content.decode('utf-8')):
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.graph_fields),
+            )
+
+
+class RackTest(APITestCase):
+    fixtures = [
+        'dcim',
+        'ipam'
+    ]
+
+    nested_fields = [
+        'id',
+        'name',
+        'facility_id',
+        'display_name'
+    ]
+
+    standard_fields = [
+        'id',
+        'name',
+        'facility_id',
+        'display_name',
+        'site',
+        'group',
+        'tenant',
+        'role',
+        'type',
+        'width',
+        'u_height',
+        'desc_units',
+        'comments',
+        'custom_fields',
+    ]
+
+    detail_fields = [
+        'id',
+        'name',
+        'facility_id',
+        'display_name',
+        'site',
+        'group',
+        'tenant',
+        'role',
+        'type',
+        'width',
+        'u_height',
+        'desc_units',
+        'reservations',
+        'comments',
+        'custom_fields',
+        'front_units',
+        'rear_units'
+    ]
+
+    def test_get_list(self, endpoint='/{}api/dcim/racks/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+            self.assertEqual(
+                sorted(i.get('site').keys()),
+                sorted(SiteTest.nested_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/racks/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.detail_fields),
+        )
+        self.assertEqual(
+            sorted(content.get('site').keys()),
+            sorted(SiteTest.nested_fields),
+        )
+
+
+class ManufacturersTest(APITestCase):
+
+    fixtures = [
+        'dcim',
+        'ipam'
+    ]
+
+    standard_fields = [
+        'id',
+        'name',
+        'slug',
+    ]
+
+    nested_fields = standard_fields
+
+    def test_get_list(self, endpoint='/{}api/dcim/manufacturers/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/manufacturers/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )
+
+
+class DeviceTypeTest(APITestCase):
+
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = [
+        'id',
+        'manufacturer',
+        'model',
+        'slug',
+        'part_number',
+        'u_height',
+        'is_full_depth',
+        'interface_ordering',
+        'is_console_server',
+        'is_pdu',
+        'is_network_device',
+        'subdevice_role',
+        'comments',
+        'custom_fields',
+        'instance_count',
+    ]
+
+    nested_fields = [
+        'id',
+        'manufacturer',
+        'model',
+        'slug'
+    ]
+
+    def test_get_list(self, endpoint='/{}api/dcim/device-types/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+
+    def test_detail_list(self, endpoint='/{}api/dcim/device-types/1/'.format(settings.BASE_PATH)):
+        # TODO: details returns list view.
+        # response = self.client.get(endpoint)
+        # content = json.loads(response.content.decode('utf-8'))
+        # self.assertEqual(response.status_code, status.HTTP_200_OK)
+        # self.assertEqual(
+        #     sorted(content.keys()),
+        #     sorted(self.standard_fields),
+        # )
+        # self.assertEqual(
+        #     sorted(content.get('manufacturer').keys()),
+        #     sorted(ManufacturersTest.nested_fields),
+        # )
+        pass
+
+
+class DeviceRolesTest(APITestCase):
+
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = ['id', 'name', 'slug', 'color']
+
+    nested_fields = ['id', 'name', 'slug']
+
+    def test_get_list(self, endpoint='/{}api/dcim/device-roles/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/device-roles/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )
+
+
+class PlatformsTest(APITestCase):
+
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = ['id', 'name', 'slug', 'rpc_client']
+
+    nested_fields = ['id', 'name', 'slug']
+
+    def test_get_list(self, endpoint='/{}api/dcim/platforms/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/platforms/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )
+
+
+class DeviceTest(APITestCase):
+
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = [
+        'id',
+        'name',
+        'display_name',
+        'device_type',
+        'device_role',
+        'tenant',
+        'platform',
+        'serial',
+        'asset_tag',
+        'site',
+        'rack',
+        'position',
+        'face',
+        'parent_device',
+        'status',
+        'primary_ip',
+        'primary_ip4',
+        'primary_ip6',
+        'comments',
+        'custom_fields',
+    ]
+
+    nested_fields = ['id', 'name', 'display_name']
+
+    def test_get_list(self, endpoint='/{}api/dcim/devices/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for device in content:
+            self.assertEqual(
+                sorted(device.keys()),
+                sorted(self.standard_fields),
+            )
+            self.assertEqual(
+                sorted(device.get('device_type')),
+                sorted(DeviceTypeTest.nested_fields),
+            )
+            self.assertEqual(
+                sorted(device.get('device_role')),
+                sorted(DeviceRolesTest.nested_fields),
+            )
+            if device.get('platform'):
+                self.assertEqual(
+                    sorted(device.get('platform')),
+                    sorted(PlatformsTest.nested_fields),
+                )
+            self.assertEqual(
+                sorted(device.get('rack')),
+                sorted(RackTest.nested_fields),
+            )
+
+    def test_get_list_flat(self, endpoint='/{}api/dcim/devices/?format=json_flat'.format(settings.BASE_PATH)):
+
+        flat_fields = [
+            'asset_tag',
+            'comments',
+            'device_role_id',
+            'device_role_name',
+            'device_role_slug',
+            'device_type_id',
+            'device_type_manufacturer_id',
+            'device_type_manufacturer_name',
+            'device_type_manufacturer_slug',
+            'device_type_model',
+            'device_type_slug',
+            'display_name',
+            'face',
+            'id',
+            'name',
+            'parent_device',
+            'platform_id',
+            'platform_name',
+            'platform_slug',
+            'position',
+            'primary_ip_address',
+            'primary_ip_family',
+            'primary_ip_id',
+            'primary_ip4_address',
+            'primary_ip4_family',
+            'primary_ip4_id',
+            'primary_ip6',
+            'site_id',
+            'site_name',
+            'site_slug',
+            'rack_display_name',
+            'rack_facility_id',
+            'rack_id',
+            'rack_name',
+            'serial',
+            'status',
+            'tenant',
+        ]
+
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        device = content[0]
+        self.assertEqual(
+            sorted(device.keys()),
+            sorted(flat_fields),
+        )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/devices/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )
+
+
+class ConsoleServerPortsTest(APITestCase):
+
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = ['id', 'device', 'name', 'connected_console']
+
+    nested_fields = ['id', 'device', 'name']
+
+    def test_get_list(self, endpoint='/{}api/dcim/devices/9/console-server-ports/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for console_port in content:
+            self.assertEqual(
+                sorted(console_port.keys()),
+                sorted(self.standard_fields),
+            )
+            self.assertEqual(
+                sorted(console_port.get('device')),
+                sorted(DeviceTest.nested_fields),
+            )
+
+
+class ConsolePortsTest(APITestCase):
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = ['id', 'device', 'name', 'cs_port', 'connection_status']
+
+    nested_fields = ['id', 'device', 'name']
+
+    def test_get_list(self, endpoint='/{}api/dcim/devices/1/console-ports/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for console_port in content:
+            self.assertEqual(
+                sorted(console_port.keys()),
+                sorted(self.standard_fields),
+            )
+            self.assertEqual(
+                sorted(console_port.get('device')),
+                sorted(DeviceTest.nested_fields),
+            )
+            self.assertEqual(
+                sorted(console_port.get('cs_port')),
+                sorted(ConsoleServerPortsTest.nested_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/console-ports/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )
+        self.assertEqual(
+            sorted(content.get('device')),
+            sorted(DeviceTest.nested_fields),
+        )
+
+
+class PowerPortsTest(APITestCase):
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = ['id', 'device', 'name', 'power_outlet', 'connection_status']
+
+    nested_fields = ['id', 'device', 'name']
+
+    def test_get_list(self, endpoint='/{}api/dcim/devices/1/power-ports/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+            self.assertEqual(
+                sorted(i.get('device')),
+                sorted(DeviceTest.nested_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/power-ports/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )
+        self.assertEqual(
+            sorted(content.get('device')),
+            sorted(DeviceTest.nested_fields),
+        )
+
+
+class PowerOutletsTest(APITestCase):
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = ['id', 'device', 'name', 'connected_port']
+
+    nested_fields = ['id', 'device', 'name']
+
+    def test_get_list(self, endpoint='/{}api/dcim/devices/11/power-outlets/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+            self.assertEqual(
+                sorted(i.get('device')),
+                sorted(DeviceTest.nested_fields),
+            )
+
+
+class InterfaceTest(APITestCase):
+    fixtures = ['dcim', 'ipam', 'extras']
+
+    standard_fields = [
+        'id',
+        'device',
+        'name',
+        'form_factor',
+        'lag',
+        'mac_address',
+        'mgmt_only',
+        'description',
+        'is_connected'
+    ]
+
+    nested_fields = ['id', 'device', 'name']
+
+    detail_fields = [
+        'id',
+        'device',
+        'name',
+        'form_factor',
+        'lag',
+        'mac_address',
+        'mgmt_only',
+        'description',
+        'is_connected',
+        'connected_interface'
+    ]
+
+    connection_fields = [
+        'id',
+        'interface_a',
+        'interface_b',
+        'connection_status',
+    ]
+
+    def test_get_list(self, endpoint='/{}api/dcim/devices/1/interfaces/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(self.standard_fields),
+            )
+            self.assertEqual(
+                sorted(i.get('device')),
+                sorted(DeviceTest.nested_fields),
+            )
+
+    def test_get_detail(self, endpoint='/{}api/dcim/interfaces/1/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.detail_fields),
+        )
+        self.assertEqual(
+            sorted(content.get('device')),
+            sorted(DeviceTest.nested_fields),
+        )
+
+    def test_get_graph_list(self, endpoint='/{}api/dcim/interfaces/1/graphs/'.format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        for i in content:
+            self.assertEqual(
+                sorted(i.keys()),
+                sorted(SiteTest.graph_fields),
+            )
+
+    def test_get_interface_connections(self, endpoint='/{}api/dcim/interface-connections/4/'
+                                       .format(settings.BASE_PATH)):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.connection_fields),
+        )
+
+
+class RelatedConnectionsTest(APITestCase):
+
+    fixtures = ['dcim', 'ipam']
+
+    standard_fields = [
+        'device',
+        'console-ports',
+        'power-ports',
+        'interfaces',
+    ]
+
+    def test_get_list(self, endpoint=('/{}api/dcim/related-connections/?peer-device=test1-edge1&peer-interface=xe-0/0/3'
+                                      .format(settings.BASE_PATH))):
+        response = self.client.get(endpoint)
+        content = json.loads(response.content.decode('utf-8'))
+        self.assertEqual(response.status_code, status.HTTP_200_OK)
+        self.assertEqual(
+            sorted(content.keys()),
+            sorted(self.standard_fields),
+        )

netbox/dcim/tests/test_forms.py

@@ -1,7 +1,4 @@
-from __future__ import unicode_literals
-
 from django.test import TestCase
-
 from dcim.forms import *
 from dcim.models import *
 

netbox/dcim/tests/test_models.py

@@ -1,7 +1,4 @@
-from __future__ import unicode_literals
-
 from django.test import TestCase
-
 from dcim.models import *
 
 

netbox/dcim/urls.py

@@ -1,42 +1,37 @@
-from __future__ import unicode_literals
-
 from django.conf.urls import url
 
-from extras.views import ImageAttachmentEditView
+from ipam.views import ServiceEditView
-from ipam.views import ServiceCreateView
 from secrets.views import secret_add
-from .models import Device, Rack, Site
+
 from . import views
 
 
-app_name = 'dcim'
 urlpatterns = [
 
     # Regions
     url(r'^regions/$', views.RegionListView.as_view(), name='region_list'),
-    url(r'^regions/add/$', views.RegionCreateView.as_view(), name='region_add'),
+    url(r'^regions/add/$', views.RegionEditView.as_view(), name='region_add'),
     url(r'^regions/delete/$', views.RegionBulkDeleteView.as_view(), name='region_bulk_delete'),
     url(r'^regions/(?P<pk>\d+)/edit/$', views.RegionEditView.as_view(), name='region_edit'),
 
     # Sites
     url(r'^sites/$', views.SiteListView.as_view(), name='site_list'),
-    url(r'^sites/add/$', views.SiteCreateView.as_view(), name='site_add'),
+    url(r'^sites/add/$', views.SiteEditView.as_view(), name='site_add'),
     url(r'^sites/import/$', views.SiteBulkImportView.as_view(), name='site_import'),
     url(r'^sites/edit/$', views.SiteBulkEditView.as_view(), name='site_bulk_edit'),
-    url(r'^sites/(?P<slug>[\w-]+)/$', views.SiteView.as_view(), name='site'),
+    url(r'^sites/(?P<slug>[\w-]+)/$', views.site, name='site'),
     url(r'^sites/(?P<slug>[\w-]+)/edit/$', views.SiteEditView.as_view(), name='site_edit'),
     url(r'^sites/(?P<slug>[\w-]+)/delete/$', views.SiteDeleteView.as_view(), name='site_delete'),
-    url(r'^sites/(?P<object_id>\d+)/images/add/$', ImageAttachmentEditView.as_view(), name='site_add_image', kwargs={'model': Site}),
 
     # Rack groups
     url(r'^rack-groups/$', views.RackGroupListView.as_view(), name='rackgroup_list'),
-    url(r'^rack-groups/add/$', views.RackGroupCreateView.as_view(), name='rackgroup_add'),
+    url(r'^rack-groups/add/$', views.RackGroupEditView.as_view(), name='rackgroup_add'),
     url(r'^rack-groups/delete/$', views.RackGroupBulkDeleteView.as_view(), name='rackgroup_bulk_delete'),
     url(r'^rack-groups/(?P<pk>\d+)/edit/$', views.RackGroupEditView.as_view(), name='rackgroup_edit'),
 
     # Rack roles
     url(r'^rack-roles/$', views.RackRoleListView.as_view(), name='rackrole_list'),
-    url(r'^rack-roles/add/$', views.RackRoleCreateView.as_view(), name='rackrole_add'),
+    url(r'^rack-roles/add/$', views.RackRoleEditView.as_view(), name='rackrole_add'),
     url(r'^rack-roles/delete/$', views.RackRoleBulkDeleteView.as_view(), name='rackrole_bulk_delete'),
     url(r'^rack-roles/(?P<pk>\d+)/edit/$', views.RackRoleEditView.as_view(), name='rackrole_edit'),
 
@@ -48,88 +43,86 @@ urlpatterns = [
 
     # Racks
     url(r'^racks/$', views.RackListView.as_view(), name='rack_list'),
-    url(r'^rack-elevations/$', views.RackElevationListView.as_view(), name='rack_elevation_list'),
     url(r'^racks/add/$', views.RackEditView.as_view(), name='rack_add'),
     url(r'^racks/import/$', views.RackBulkImportView.as_view(), name='rack_import'),
     url(r'^racks/edit/$', views.RackBulkEditView.as_view(), name='rack_bulk_edit'),
     url(r'^racks/delete/$', views.RackBulkDeleteView.as_view(), name='rack_bulk_delete'),
-    url(r'^racks/(?P<pk>\d+)/$', views.RackView.as_view(), name='rack'),
+    url(r'^racks/(?P<pk>\d+)/$', views.rack, name='rack'),
     url(r'^racks/(?P<pk>\d+)/edit/$', views.RackEditView.as_view(), name='rack_edit'),
     url(r'^racks/(?P<pk>\d+)/delete/$', views.RackDeleteView.as_view(), name='rack_delete'),
-    url(r'^racks/(?P<rack>\d+)/reservations/add/$', views.RackReservationCreateView.as_view(), name='rack_add_reservation'),
+    url(r'^racks/(?P<rack>\d+)/reservations/add/$', views.RackReservationEditView.as_view(), name='rack_add_reservation'),
-    url(r'^racks/(?P<object_id>\d+)/images/add/$', ImageAttachmentEditView.as_view(), name='rack_add_image', kwargs={'model': Rack}),
 
     # Manufacturers
     url(r'^manufacturers/$', views.ManufacturerListView.as_view(), name='manufacturer_list'),
-    url(r'^manufacturers/add/$', views.ManufacturerCreateView.as_view(), name='manufacturer_add'),
+    url(r'^manufacturers/add/$', views.ManufacturerEditView.as_view(), name='manufacturer_add'),
     url(r'^manufacturers/delete/$', views.ManufacturerBulkDeleteView.as_view(), name='manufacturer_bulk_delete'),
     url(r'^manufacturers/(?P<slug>[\w-]+)/edit/$', views.ManufacturerEditView.as_view(), name='manufacturer_edit'),
 
     # Device types
     url(r'^device-types/$', views.DeviceTypeListView.as_view(), name='devicetype_list'),
-    url(r'^device-types/add/$', views.DeviceTypeCreateView.as_view(), name='devicetype_add'),
+    url(r'^device-types/add/$', views.DeviceTypeEditView.as_view(), name='devicetype_add'),
     url(r'^device-types/edit/$', views.DeviceTypeBulkEditView.as_view(), name='devicetype_bulk_edit'),
     url(r'^device-types/delete/$', views.DeviceTypeBulkDeleteView.as_view(), name='devicetype_bulk_delete'),
-    url(r'^device-types/(?P<pk>\d+)/$', views.DeviceTypeView.as_view(), name='devicetype'),
+    url(r'^device-types/(?P<pk>\d+)/$', views.devicetype, name='devicetype'),
     url(r'^device-types/(?P<pk>\d+)/edit/$', views.DeviceTypeEditView.as_view(), name='devicetype_edit'),
     url(r'^device-types/(?P<pk>\d+)/delete/$', views.DeviceTypeDeleteView.as_view(), name='devicetype_delete'),
 
     # Console port templates
-    url(r'^device-types/(?P<pk>\d+)/console-ports/add/$', views.ConsolePortTemplateCreateView.as_view(), name='devicetype_add_consoleport'),
+    url(r'^device-types/(?P<pk>\d+)/console-ports/add/$', views.ConsolePortTemplateAddView.as_view(), name='devicetype_add_consoleport'),
     url(r'^device-types/(?P<pk>\d+)/console-ports/delete/$', views.ConsolePortTemplateBulkDeleteView.as_view(), name='devicetype_delete_consoleport'),
 
     # Console server port templates
-    url(r'^device-types/(?P<pk>\d+)/console-server-ports/add/$', views.ConsoleServerPortTemplateCreateView.as_view(), name='devicetype_add_consoleserverport'),
+    url(r'^device-types/(?P<pk>\d+)/console-server-ports/add/$', views.ConsoleServerPortTemplateAddView.as_view(), name='devicetype_add_consoleserverport'),
     url(r'^device-types/(?P<pk>\d+)/console-server-ports/delete/$', views.ConsoleServerPortTemplateBulkDeleteView.as_view(), name='devicetype_delete_consoleserverport'),
 
     # Power port templates
-    url(r'^device-types/(?P<pk>\d+)/power-ports/add/$', views.PowerPortTemplateCreateView.as_view(), name='devicetype_add_powerport'),
+    url(r'^device-types/(?P<pk>\d+)/power-ports/add/$', views.PowerPortTemplateAddView.as_view(), name='devicetype_add_powerport'),
     url(r'^device-types/(?P<pk>\d+)/power-ports/delete/$', views.PowerPortTemplateBulkDeleteView.as_view(), name='devicetype_delete_powerport'),
 
     # Power outlet templates
-    url(r'^device-types/(?P<pk>\d+)/power-outlets/add/$', views.PowerOutletTemplateCreateView.as_view(), name='devicetype_add_poweroutlet'),
+    url(r'^device-types/(?P<pk>\d+)/power-outlets/add/$', views.PowerOutletTemplateAddView.as_view(), name='devicetype_add_poweroutlet'),
     url(r'^device-types/(?P<pk>\d+)/power-outlets/delete/$', views.PowerOutletTemplateBulkDeleteView.as_view(), name='devicetype_delete_poweroutlet'),
 
     # Interface templates
-    url(r'^device-types/(?P<pk>\d+)/interfaces/add/$', views.InterfaceTemplateCreateView.as_view(), name='devicetype_add_interface'),
+    url(r'^device-types/(?P<pk>\d+)/interfaces/add/$', views.InterfaceTemplateAddView.as_view(), name='devicetype_add_interface'),
     url(r'^device-types/(?P<pk>\d+)/interfaces/edit/$', views.InterfaceTemplateBulkEditView.as_view(), name='devicetype_bulkedit_interface'),
     url(r'^device-types/(?P<pk>\d+)/interfaces/delete/$', views.InterfaceTemplateBulkDeleteView.as_view(), name='devicetype_delete_interface'),
 
     # Device bay templates
-    url(r'^device-types/(?P<pk>\d+)/device-bays/add/$', views.DeviceBayTemplateCreateView.as_view(), name='devicetype_add_devicebay'),
+    url(r'^device-types/(?P<pk>\d+)/device-bays/add/$', views.DeviceBayTemplateAddView.as_view(), name='devicetype_add_devicebay'),
     url(r'^device-types/(?P<pk>\d+)/device-bays/delete/$', views.DeviceBayTemplateBulkDeleteView.as_view(), name='devicetype_delete_devicebay'),
 
     # Device roles
     url(r'^device-roles/$', views.DeviceRoleListView.as_view(), name='devicerole_list'),
-    url(r'^device-roles/add/$', views.DeviceRoleCreateView.as_view(), name='devicerole_add'),
+    url(r'^device-roles/add/$', views.DeviceRoleEditView.as_view(), name='devicerole_add'),
     url(r'^device-roles/delete/$', views.DeviceRoleBulkDeleteView.as_view(), name='devicerole_bulk_delete'),
     url(r'^device-roles/(?P<slug>[\w-]+)/edit/$', views.DeviceRoleEditView.as_view(), name='devicerole_edit'),
 
     # Platforms
     url(r'^platforms/$', views.PlatformListView.as_view(), name='platform_list'),
-    url(r'^platforms/add/$', views.PlatformCreateView.as_view(), name='platform_add'),
+    url(r'^platforms/add/$', views.PlatformEditView.as_view(), name='platform_add'),
     url(r'^platforms/delete/$', views.PlatformBulkDeleteView.as_view(), name='platform_bulk_delete'),
     url(r'^platforms/(?P<slug>[\w-]+)/edit/$', views.PlatformEditView.as_view(), name='platform_edit'),
 
     # Devices
     url(r'^devices/$', views.DeviceListView.as_view(), name='device_list'),
-    url(r'^devices/add/$', views.DeviceCreateView.as_view(), name='device_add'),
+    url(r'^devices/add/$', views.DeviceEditView.as_view(), name='device_add'),
     url(r'^devices/import/$', views.DeviceBulkImportView.as_view(), name='device_import'),
     url(r'^devices/import/child-devices/$', views.ChildDeviceBulkImportView.as_view(), name='device_import_child'),
     url(r'^devices/edit/$', views.DeviceBulkEditView.as_view(), name='device_bulk_edit'),
     url(r'^devices/delete/$', views.DeviceBulkDeleteView.as_view(), name='device_bulk_delete'),
-    url(r'^devices/(?P<pk>\d+)/$', views.DeviceView.as_view(), name='device'),
+    url(r'^devices/(?P<pk>\d+)/$', views.device, name='device'),
     url(r'^devices/(?P<pk>\d+)/edit/$', views.DeviceEditView.as_view(), name='device_edit'),
     url(r'^devices/(?P<pk>\d+)/delete/$', views.DeviceDeleteView.as_view(), name='device_delete'),
-    url(r'^devices/(?P<pk>\d+)/inventory/$', views.DeviceInventoryView.as_view(), name='device_inventory'),
+    url(r'^devices/(?P<pk>\d+)/inventory/$', views.device_inventory, name='device_inventory'),
-    url(r'^devices/(?P<pk>\d+)/lldp-neighbors/$', views.DeviceLLDPNeighborsView.as_view(), name='device_lldp_neighbors'),
+    url(r'^devices/(?P<pk>\d+)/lldp-neighbors/$', views.device_lldp_neighbors, name='device_lldp_neighbors'),
+    url(r'^devices/(?P<pk>\d+)/ip-addresses/assign/$', views.ipaddress_assign, name='ipaddress_assign'),
     url(r'^devices/(?P<pk>\d+)/add-secret/$', secret_add, name='device_addsecret'),
-    url(r'^devices/(?P<device>\d+)/services/assign/$', ServiceCreateView.as_view(), name='service_assign'),
+    url(r'^devices/(?P<device>\d+)/services/assign/$', ServiceEditView.as_view(), name='service_assign'),
-    url(r'^devices/(?P<object_id>\d+)/images/add/$', ImageAttachmentEditView.as_view(), name='device_add_image', kwargs={'model': Device}),
 
     # Console ports
     url(r'^devices/console-ports/add/$', views.DeviceBulkAddConsolePortView.as_view(), name='device_bulk_add_consoleport'),
-    url(r'^devices/(?P<pk>\d+)/console-ports/add/$', views.ConsolePortCreateView.as_view(), name='consoleport_add'),
+    url(r'^devices/(?P<pk>\d+)/console-ports/add/$', views.ConsolePortAddView.as_view(), name='consoleport_add'),
     url(r'^devices/(?P<pk>\d+)/console-ports/delete/$', views.ConsolePortBulkDeleteView.as_view(), name='consoleport_bulk_delete'),
     url(r'^console-ports/(?P<pk>\d+)/connect/$', views.consoleport_connect, name='consoleport_connect'),
     url(r'^console-ports/(?P<pk>\d+)/disconnect/$', views.consoleport_disconnect, name='consoleport_disconnect'),
@@ -138,8 +131,7 @@ urlpatterns = [
 
     # Console server ports
     url(r'^devices/console-server-ports/add/$', views.DeviceBulkAddConsoleServerPortView.as_view(), name='device_bulk_add_consoleserverport'),
-    url(r'^devices/(?P<pk>\d+)/console-server-ports/add/$', views.ConsoleServerPortCreateView.as_view(), name='consoleserverport_add'),
+    url(r'^devices/(?P<pk>\d+)/console-server-ports/add/$', views.ConsoleServerPortAddView.as_view(), name='consoleserverport_add'),
-    url(r'^devices/(?P<pk>\d+)/console-server-ports/disconnect/$', views.ConsoleServerPortBulkDisconnectView.as_view(), name='consoleserverport_bulk_disconnect'),
     url(r'^devices/(?P<pk>\d+)/console-server-ports/delete/$', views.ConsoleServerPortBulkDeleteView.as_view(), name='consoleserverport_bulk_delete'),
     url(r'^console-server-ports/(?P<pk>\d+)/connect/$', views.consoleserverport_connect, name='consoleserverport_connect'),
     url(r'^console-server-ports/(?P<pk>\d+)/disconnect/$', views.consoleserverport_disconnect, name='consoleserverport_disconnect'),
@@ -148,7 +140,7 @@ urlpatterns = [
 
     # Power ports
     url(r'^devices/power-ports/add/$', views.DeviceBulkAddPowerPortView.as_view(), name='device_bulk_add_powerport'),
-    url(r'^devices/(?P<pk>\d+)/power-ports/add/$', views.PowerPortCreateView.as_view(), name='powerport_add'),
+    url(r'^devices/(?P<pk>\d+)/power-ports/add/$', views.PowerPortAddView.as_view(), name='powerport_add'),
     url(r'^devices/(?P<pk>\d+)/power-ports/delete/$', views.PowerPortBulkDeleteView.as_view(), name='powerport_bulk_delete'),
     url(r'^power-ports/(?P<pk>\d+)/connect/$', views.powerport_connect, name='powerport_connect'),
     url(r'^power-ports/(?P<pk>\d+)/disconnect/$', views.powerport_disconnect, name='powerport_disconnect'),
@@ -157,8 +149,7 @@ urlpatterns = [
 
     # Power outlets
     url(r'^devices/power-outlets/add/$', views.DeviceBulkAddPowerOutletView.as_view(), name='device_bulk_add_poweroutlet'),
-    url(r'^devices/(?P<pk>\d+)/power-outlets/add/$', views.PowerOutletCreateView.as_view(), name='poweroutlet_add'),
+    url(r'^devices/(?P<pk>\d+)/power-outlets/add/$', views.PowerOutletAddView.as_view(), name='poweroutlet_add'),
-    url(r'^devices/(?P<pk>\d+)/power-outlets/disconnect/$', views.PowerOutletBulkDisconnectView.as_view(), name='poweroutlet_bulk_disconnect'),
     url(r'^devices/(?P<pk>\d+)/power-outlets/delete/$', views.PowerOutletBulkDeleteView.as_view(), name='poweroutlet_bulk_delete'),
     url(r'^power-outlets/(?P<pk>\d+)/connect/$', views.poweroutlet_connect, name='poweroutlet_connect'),
     url(r'^power-outlets/(?P<pk>\d+)/disconnect/$', views.poweroutlet_disconnect, name='poweroutlet_disconnect'),
@@ -167,9 +158,8 @@ urlpatterns = [
 
     # Interfaces
     url(r'^devices/interfaces/add/$', views.DeviceBulkAddInterfaceView.as_view(), name='device_bulk_add_interface'),
-    url(r'^devices/(?P<pk>\d+)/interfaces/add/$', views.InterfaceCreateView.as_view(), name='interface_add'),
+    url(r'^devices/(?P<pk>\d+)/interfaces/add/$', views.InterfaceAddView.as_view(), name='interface_add'),
     url(r'^devices/(?P<pk>\d+)/interfaces/edit/$', views.InterfaceBulkEditView.as_view(), name='interface_bulk_edit'),
-    url(r'^devices/(?P<pk>\d+)/interfaces/disconnect/$', views.InterfaceBulkDisconnectView.as_view(), name='interface_bulk_disconnect'),
     url(r'^devices/(?P<pk>\d+)/interfaces/delete/$', views.InterfaceBulkDeleteView.as_view(), name='interface_bulk_delete'),
     url(r'^devices/(?P<pk>\d+)/interface-connections/add/$', views.interfaceconnection_add, name='interfaceconnection_add'),
     url(r'^interface-connections/(?P<pk>\d+)/delete/$', views.interfaceconnection_delete, name='interfaceconnection_delete'),
@@ -178,18 +168,13 @@ urlpatterns = [
 
     # Device bays
     url(r'^devices/device-bays/add/$', views.DeviceBulkAddDeviceBayView.as_view(), name='device_bulk_add_devicebay'),
-    url(r'^devices/(?P<pk>\d+)/bays/add/$', views.DeviceBayCreateView.as_view(), name='devicebay_add'),
+    url(r'^devices/(?P<pk>\d+)/bays/add/$', views.DeviceBayAddView.as_view(), name='devicebay_add'),
     url(r'^devices/(?P<pk>\d+)/bays/delete/$', views.DeviceBayBulkDeleteView.as_view(), name='devicebay_bulk_delete'),
     url(r'^device-bays/(?P<pk>\d+)/edit/$', views.DeviceBayEditView.as_view(), name='devicebay_edit'),
     url(r'^device-bays/(?P<pk>\d+)/delete/$', views.DeviceBayDeleteView.as_view(), name='devicebay_delete'),
     url(r'^device-bays/(?P<pk>\d+)/populate/$', views.devicebay_populate, name='devicebay_populate'),
     url(r'^device-bays/(?P<pk>\d+)/depopulate/$', views.devicebay_depopulate, name='devicebay_depopulate'),
 
-    # Inventory items
-    url(r'^devices/(?P<device>\d+)/inventory-items/add/$', views.InventoryItemEditView.as_view(), name='inventoryitem_add'),
-    url(r'^inventory-items/(?P<pk>\d+)/edit/$', views.InventoryItemEditView.as_view(), name='inventoryitem_edit'),
-    url(r'^inventory-items/(?P<pk>\d+)/delete/$', views.InventoryItemDeleteView.as_view(), name='inventoryitem_delete'),
-
     # Console/power/interface connections
     url(r'^console-connections/$', views.ConsoleConnectionsListView.as_view(), name='console_connections_list'),
     url(r'^console-connections/import/$', views.ConsoleConnectionsBulkImportView.as_view(), name='console_connections_import'),
@@ -198,4 +183,9 @@ urlpatterns = [
     url(r'^interface-connections/$', views.InterfaceConnectionsListView.as_view(), name='interface_connections_list'),
     url(r'^interface-connections/import/$', views.InterfaceConnectionsBulkImportView.as_view(), name='interface_connections_import'),
 
+    # Modules
+    url(r'^devices/(?P<device>\d+)/modules/add/$', views.ModuleEditView.as_view(), name='module_add'),
+    url(r'^modules/(?P<pk>\d+)/edit/$', views.ModuleEditView.as_view(), name='module_edit'),
+    url(r'^modules/(?P<pk>\d+)/delete/$', views.ModuleDeleteView.as_view(), name='module_delete'),
+
 ]

netbox/extras/admin.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from django import forms
 from django.contrib import admin
 from django.utils.safestring import mark_safe

netbox/extras/api/customfields.py

@@ -1,164 +0,0 @@
-from __future__ import unicode_literals
-from datetime import datetime
-
-from rest_framework import serializers
-from rest_framework.exceptions import ValidationError
-
-from django.contrib.contenttypes.models import ContentType
-from django.db import transaction
-
-from extras.models import (
-    CF_TYPE_BOOLEAN, CF_TYPE_DATE, CF_TYPE_SELECT, CustomField, CustomFieldChoice, CustomFieldValue,
-)
-
-
-#
-# Custom fields
-#
-
-class CustomFieldsSerializer(serializers.BaseSerializer):
-
-    def to_representation(self, obj):
-        return obj
-
-    def to_internal_value(self, data):
-
-        content_type = ContentType.objects.get_for_model(self.parent.Meta.model)
-        custom_fields = {field.name: field for field in CustomField.objects.filter(obj_type=content_type)}
-
-        for field_name, value in data.items():
-
-            cf = custom_fields[field_name]
-
-            # Validate custom field name
-            if field_name not in custom_fields:
-                raise ValidationError("Invalid custom field for {} objects: {}".format(content_type, field_name))
-
-            # Validate boolean
-            if cf.type == CF_TYPE_BOOLEAN and value not in [True, False, 1, 0]:
-                raise ValidationError("Invalid value for boolean field {}: {}".format(field_name, value))
-
-            # Validate date
-            if cf.type == CF_TYPE_DATE:
-                try:
-                    datetime.strptime(value, '%Y-%m-%d')
-                except ValueError:
-                    raise ValidationError("Invalid date for field {}: {}. (Required format is YYYY-MM-DD.)".format(
-                        field_name, value
-                    ))
-
-            # Validate selected choice
-            if cf.type == CF_TYPE_SELECT:
-                try:
-                    value = int(value)
-                except ValueError:
-                    raise ValidationError("{}: Choice selections must be passed as integers.".format(field_name))
-                valid_choices = [c.pk for c in cf.choices.all()]
-                if value not in valid_choices:
-                    raise ValidationError("Invalid choice for field {}: {}".format(field_name, value))
-
-        # Check for missing required fields
-        missing_fields = []
-        for field_name, field in custom_fields.items():
-            if field.required and field_name not in data:
-                missing_fields.append(field_name)
-        if missing_fields:
-            raise ValidationError("Missing required fields: {}".format(u", ".join(missing_fields)))
-
-        return data
-
-
-class CustomFieldModelSerializer(serializers.ModelSerializer):
-    """
-    Extends ModelSerializer to render any CustomFields and their values associated with an object.
-    """
-    custom_fields = CustomFieldsSerializer(required=False)
-
-    def __init__(self, *args, **kwargs):
-
-        def _populate_custom_fields(instance, fields):
-            custom_fields = {f.name: None for f in fields}
-            for cfv in instance.custom_field_values.all():
-                if cfv.field.type == CF_TYPE_SELECT:
-                    custom_fields[cfv.field.name] = CustomFieldChoiceSerializer(cfv.value).data
-                else:
-                    custom_fields[cfv.field.name] = cfv.value
-            instance.custom_fields = custom_fields
-
-        super(CustomFieldModelSerializer, self).__init__(*args, **kwargs)
-
-        if self.instance is not None:
-
-            # Retrieve the set of CustomFields which apply to this type of object
-            content_type = ContentType.objects.get_for_model(self.Meta.model)
-            fields = CustomField.objects.filter(obj_type=content_type)
-
-            # Populate CustomFieldValues for each instance from database
-            try:
-                for obj in self.instance:
-                    _populate_custom_fields(obj, fields)
-            except TypeError:
-                _populate_custom_fields(self.instance, fields)
-
-    def _save_custom_fields(self, instance, custom_fields):
-        content_type = ContentType.objects.get_for_model(self.Meta.model)
-        for field_name, value in custom_fields.items():
-            custom_field = CustomField.objects.get(name=field_name)
-            CustomFieldValue.objects.update_or_create(
-                field=custom_field,
-                obj_type=content_type,
-                obj_id=instance.pk,
-                defaults={'serialized_value': custom_field.serialize_value(value)},
-            )
-
-    def validate(self, data):
-        """
-        Enforce model validation (see utilities.api.ModelValidationMixin)
-        """
-        model_data = data.copy()
-        model_data.pop('custom_fields', None)
-        instance = self.Meta.model(**model_data)
-        instance.clean()
-        return data
-
-    def create(self, validated_data):
-
-        custom_fields = validated_data.pop('custom_fields', None)
-
-        with transaction.atomic():
-
-            instance = super(CustomFieldModelSerializer, self).create(validated_data)
-
-            # Save custom fields
-            if custom_fields is not None:
-                self._save_custom_fields(instance, custom_fields)
-                instance.custom_fields = custom_fields
-
-        return instance
-
-    def update(self, instance, validated_data):
-
-        custom_fields = validated_data.pop('custom_fields', None)
-
-        with transaction.atomic():
-
-            instance = super(CustomFieldModelSerializer, self).update(instance, validated_data)
-
-            # Save custom fields
-            if custom_fields is not None:
-                self._save_custom_fields(instance, custom_fields)
-                instance.custom_fields = custom_fields
-
-        return instance
-
-
-class CustomFieldChoiceSerializer(serializers.ModelSerializer):
-    """
-    Imitate utilities.api.ChoiceFieldSerializer
-    """
-    value = serializers.IntegerField(source='pk')
-    label = serializers.CharField(source='value')
-
-    class Meta:
-        model = CustomFieldChoice
-        fields = ['value', 'label']

netbox/extras/api/renderers.py

@@ -0,0 +1,88 @@
+import json
+from rest_framework import renderers
+
+
+# IP address family designations
+AF = {
+    4: 'A',
+    6: 'AAAA',
+}
+
+
+class FormlessBrowsableAPIRenderer(renderers.BrowsableAPIRenderer):
+    """
+    An instance of the browseable API with forms suppressed. Useful for POST endpoints that don't create objects.
+    """
+    def show_form_for_method(self, *args, **kwargs):
+        return False
+
+
+class BINDZoneRenderer(renderers.BaseRenderer):
+    """
+    Generate a BIND zone file from a list of DNS records.
+        Required fields: `name`, `primary_ip`
+    """
+    media_type = 'text/plain'
+    format = 'bind-zone'
+
+    def render(self, data, media_type=None, renderer_context=None):
+        records = []
+        for record in data:
+            if record.get('name') and record.get('primary_ip'):
+                try:
+                    records.append("{} IN {} {}".format(
+                        record['name'],
+                        AF[record['primary_ip']['family']],
+                        record['primary_ip']['address'].split('/')[0],
+                    ))
+                except KeyError:
+                    pass
+        return '\n'.join(records)
+
+
+class FlatJSONRenderer(renderers.BaseRenderer):
+    """
+    Flattens a nested JSON response.
+    """
+    format = 'json_flat'
+    media_type = 'application/json'
+
+    def render(self, data, media_type=None, renderer_context=None):
+
+        def flatten(entry):
+            for key, val in entry.items():
+                if isinstance(val, dict):
+                    for child_key, child_val in flatten(val):
+                        yield "{}_{}".format(key, child_key), child_val
+                else:
+                    yield key, val
+
+        return json.dumps([dict(flatten(i)) for i in data])
+
+
+class FreeRADIUSClientsRenderer(renderers.BaseRenderer):
+    """
+    Generate a FreeRADIUS clients.conf file from a list of Secrets.
+    """
+    media_type = 'text/plain'
+    format = 'freeradius'
+
+    CLIENT_TEMPLATE = """client {name} {{
+    ipaddr = {ip}
+    secret = {secret}
+}}"""
+
+    def render(self, data, media_type=None, renderer_context=None):
+        clients = []
+        try:
+            for secret in data:
+                if secret['device']['primary_ip'] and secret['plaintext']:
+                    client = self.CLIENT_TEMPLATE.format(
+                        name=secret['device']['name'],
+                        ip=secret['device']['primary_ip']['address'].split('/')[0],
+                        secret=secret['plaintext']
+                    )
+                    clients.append(client)
+        except:
+            pass
+        return '\n'.join(clients)

netbox/extras/api/serializers.py

@@ -1,140 +1,56 @@
-from __future__ import unicode_literals
-
-from django.core.exceptions import ObjectDoesNotExist
-
 from rest_framework import serializers
 
-from dcim.api.serializers import NestedDeviceSerializer, NestedRackSerializer, NestedSiteSerializer
+from extras.models import CF_TYPE_SELECT, CustomFieldChoice, Graph
-from dcim.models import Device, Rack, Site
-from extras.models import (
-    ACTION_CHOICES, ExportTemplate, Graph, GRAPH_TYPE_CHOICES, ImageAttachment, TopologyMap, UserAction,
-)
-from users.api.serializers import NestedUserSerializer
-from utilities.api import ChoiceFieldSerializer, ContentTypeFieldSerializer, ModelValidationMixin
 
 
-#
+class CustomFieldSerializer(serializers.Serializer):
-# Graphs
+    """
-#
+    Extends a ModelSerializer to render any CustomFields and their values associated with an object.
+    """
+    custom_fields = serializers.SerializerMethodField()
+
+    def get_custom_fields(self, obj):
+
+        # Gather all CustomFields applicable to this object
+        fields = {cf.name: None for cf in self.context['view'].custom_fields}
+
+        # Attach any defined CustomFieldValues to their respective CustomFields
+        for cfv in obj.custom_field_values.all():
+
+            # Attempt to suppress database lookups for CustomFieldChoices by using the cached choice set from the view
+            # context.
+            if cfv.field.type == CF_TYPE_SELECT and hasattr(self, 'custom_field_choices'):
+                cfc = {
+                    'id': int(cfv.serialized_value),
+                    'value': self.context['view'].custom_field_choices[int(cfv.serialized_value)]
+                }
+                fields[cfv.field.name] = CustomFieldChoiceSerializer(instance=cfc).data
+            # Fall back to hitting the database in case we're in a view that doesn't inherit CustomFieldModelAPIView.
+            elif cfv.field.type == CF_TYPE_SELECT:
+                fields[cfv.field.name] = CustomFieldChoiceSerializer(instance=cfv.value).data
+            else:
+                fields[cfv.field.name] = cfv.value
+
+        return fields
+
+
+class CustomFieldChoiceSerializer(serializers.ModelSerializer):
+
+    class Meta:
+        model = CustomFieldChoice
+        fields = ['id', 'value']
+
 
 class GraphSerializer(serializers.ModelSerializer):
-    type = ChoiceFieldSerializer(choices=GRAPH_TYPE_CHOICES)
-
-    class Meta:
-        model = Graph
-        fields = ['id', 'type', 'weight', 'name', 'source', 'link']
-
-
-class WritableGraphSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = Graph
-        fields = ['id', 'type', 'weight', 'name', 'source', 'link']
-
-
-class RenderedGraphSerializer(serializers.ModelSerializer):
     embed_url = serializers.SerializerMethodField()
     embed_link = serializers.SerializerMethodField()
-    type = ChoiceFieldSerializer(choices=GRAPH_TYPE_CHOICES)
 
     class Meta:
         model = Graph
-        fields = ['id', 'type', 'weight', 'name', 'embed_url', 'embed_link']
+        fields = ['name', 'embed_url', 'embed_link']
 
     def get_embed_url(self, obj):
         return obj.embed_url(self.context['graphed_object'])
 
     def get_embed_link(self, obj):
         return obj.embed_link(self.context['graphed_object'])
-
-
-#
-# Export templates
-#
-
-class ExportTemplateSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = ExportTemplate
-        fields = ['id', 'content_type', 'name', 'description', 'template_code', 'mime_type', 'file_extension']
-
-
-#
-# Topology maps
-#
-
-class TopologyMapSerializer(serializers.ModelSerializer):
-    site = NestedSiteSerializer()
-
-    class Meta:
-        model = TopologyMap
-        fields = ['id', 'name', 'slug', 'site', 'device_patterns', 'description']
-
-
-class WritableTopologyMapSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = TopologyMap
-        fields = ['id', 'name', 'slug', 'site', 'device_patterns', 'description']
-
-
-#
-# Image attachments
-#
-
-class ImageAttachmentSerializer(serializers.ModelSerializer):
-    parent = serializers.SerializerMethodField()
-
-    class Meta:
-        model = ImageAttachment
-        fields = ['id', 'parent', 'name', 'image', 'image_height', 'image_width', 'created']
-
-    def get_parent(self, obj):
-
-        # Static mapping of models to their nested serializers
-        if isinstance(obj.parent, Device):
-            serializer = NestedDeviceSerializer
-        elif isinstance(obj.parent, Rack):
-            serializer = NestedRackSerializer
-        elif isinstance(obj.parent, Site):
-            serializer = NestedSiteSerializer
-        else:
-            raise Exception("Unexpected type of parent object for ImageAttachment")
-
-        return serializer(obj.parent, context={'request': self.context['request']}).data
-
-
-class WritableImageAttachmentSerializer(ModelValidationMixin, serializers.ModelSerializer):
-    content_type = ContentTypeFieldSerializer()
-
-    class Meta:
-        model = ImageAttachment
-        fields = ['id', 'content_type', 'object_id', 'name', 'image']
-
-    def validate(self, data):
-
-        # Validate that the parent object exists
-        try:
-            data['content_type'].get_object_for_this_type(id=data['object_id'])
-        except ObjectDoesNotExist:
-            raise serializers.ValidationError(
-                "Invalid parent object: {} ID {}".format(data['content_type'], data['object_id'])
-            )
-
-        # Enforce model validation
-        super(WritableImageAttachmentSerializer, self).validate(data)
-
-        return data
-
-
-#
-# User actions
-#
-
-class UserActionSerializer(serializers.ModelSerializer):
-    user = NestedUserSerializer()
-    action = ChoiceFieldSerializer(choices=ACTION_CHOICES)
-
-    class Meta:
-        model = UserAction
-        fields = ['id', 'time', 'user', 'action', 'message']

netbox/extras/api/urls.py

@@ -1,35 +0,0 @@
-from __future__ import unicode_literals
-
-from rest_framework import routers
-
-from . import views
-
-
-class ExtrasRootView(routers.APIRootView):
-    """
-    Extras API root view
-    """
-    def get_view_name(self):
-        return 'Extras'
-
-
-router = routers.DefaultRouter()
-router.APIRootView = ExtrasRootView
-
-# Graphs
-router.register(r'graphs', views.GraphViewSet)
-
-# Export templates
-router.register(r'export-templates', views.ExportTemplateViewSet)
-
-# Topology maps
-router.register(r'topology-maps', views.TopologyMapViewSet)
-
-# Image attachments
-router.register(r'image-attachments', views.ImageAttachmentViewSet)
-
-# Recent activity
-router.register(r'recent-activity', views.RecentActivityViewSet)
-
-app_name = 'extras-api'
-urlpatterns = router.urls

netbox/extras/api/views.py

@@ -1,97 +1,115 @@
-from __future__ import unicode_literals
+import graphviz
-
+from rest_framework import generics
-from rest_framework.decorators import detail_route
+from rest_framework.views import APIView
-from rest_framework.viewsets import ModelViewSet, ReadOnlyModelViewSet
 
 from django.contrib.contenttypes.models import ContentType
-from django.http import HttpResponse
+from django.db.models import Q
+from django.http import Http404, HttpResponse
 from django.shortcuts import get_object_or_404
 
-from extras import filters
+from circuits.models import Provider
-from extras.models import ExportTemplate, Graph, ImageAttachment, TopologyMap, UserAction
+from dcim.models import Site, Device, Interface, InterfaceConnection
-from utilities.api import WritableSerializerMixin
+from extras.models import Graph, TopologyMap, GRAPH_TYPE_INTERFACE, GRAPH_TYPE_PROVIDER, GRAPH_TYPE_SITE
-from . import serializers
+
+from .serializers import GraphSerializer
 
 
-class CustomFieldModelViewSet(ModelViewSet):
+class CustomFieldModelAPIView(object):
     """
-    Include the applicable set of CustomFields in the ModelViewSet context.
+    Include the applicable set of CustomField in the view context.
     """
 
-    def get_serializer_context(self):
+    def __init__(self):
-
+        super(CustomFieldModelAPIView, self).__init__()
-        # Gather all custom fields for the model
+        self.content_type = ContentType.objects.get_for_model(self.queryset.model)
-        content_type = ContentType.objects.get_for_model(self.queryset.model)
+        self.custom_fields = self.content_type.custom_fields.prefetch_related('choices')
-        custom_fields = content_type.custom_fields.prefetch_related('choices')
 
         # Cache all relevant CustomFieldChoices. This saves us from having to do a lookup per select field per object.
         custom_field_choices = {}
-        for field in custom_fields:
+        for field in self.custom_fields:
             for cfc in field.choices.all():
                 custom_field_choices[cfc.id] = cfc.value
-        custom_field_choices = custom_field_choices
+        self.custom_field_choices = custom_field_choices
 
-        context = super(CustomFieldModelViewSet, self).get_serializer_context()
+
-        context.update({
+class GraphListView(generics.ListAPIView):
-            'custom_fields': custom_fields,
+    """
-            'custom_field_choices': custom_field_choices,
+    Returns a list of relevant graphs
-        })
+    """
+    serializer_class = GraphSerializer
+
+    def get_serializer_context(self):
+        cls = {
+            GRAPH_TYPE_INTERFACE: Interface,
+            GRAPH_TYPE_PROVIDER: Provider,
+            GRAPH_TYPE_SITE: Site,
+        }
+        context = super(GraphListView, self).get_serializer_context()
+        context.update({'graphed_object': get_object_or_404(cls[self.kwargs.get('type')], pk=self.kwargs['pk'])})
         return context
 
     def get_queryset(self):
-        # Prefetch custom field values
+        graph_type = self.kwargs.get('type', None)
-        return super(CustomFieldModelViewSet, self).get_queryset().prefetch_related('custom_field_values__field')
+        if not graph_type:
+            raise Http404()
+        queryset = Graph.objects.filter(type=graph_type)
+        return queryset
 
 
-class GraphViewSet(WritableSerializerMixin, ModelViewSet):
+class TopologyMapView(APIView):
-    queryset = Graph.objects.all()
+    """
-    serializer_class = serializers.GraphSerializer
+    Generate a topology diagram
-    write_serializer_class = serializers.WritableGraphSerializer
+    """
-    filter_class = filters.GraphFilter
 
+    def get(self, request, slug):
 
-class ExportTemplateViewSet(WritableSerializerMixin, ModelViewSet):
+        tmap = get_object_or_404(TopologyMap, slug=slug)
-    queryset = ExportTemplate.objects.all()
-    serializer_class = serializers.ExportTemplateSerializer
-    filter_class = filters.ExportTemplateFilter
 
+        # Construct the graph
+        graph = graphviz.Graph()
+        graph.graph_attr['ranksep'] = '1'
+        for i, device_set in enumerate(tmap.device_sets):
 
-class TopologyMapViewSet(WritableSerializerMixin, ModelViewSet):
+            subgraph = graphviz.Graph(name='sg{}'.format(i))
-    queryset = TopologyMap.objects.select_related('site')
+            subgraph.graph_attr['rank'] = 'same'
-    serializer_class = serializers.TopologyMapSerializer
-    write_serializer_class = serializers.WritableTopologyMapSerializer
-    filter_class = filters.TopologyMapFilter
 
-    @detail_route()
+            # Add a pseudonode for each device_set to enforce hierarchical layout
-    def render(self, request, pk):
+            subgraph.node('set{}'.format(i), label='', shape='none', width='0')
+            if i:
+                graph.edge('set{}'.format(i - 1), 'set{}'.format(i), style='invis')
 
-        tmap = get_object_or_404(TopologyMap, pk=pk)
+            # Add each device to the graph
-        img_format = 'png'
+            devices = []
+            for query in device_set.split(';'):  # Split regexes on semicolons
+                devices += Device.objects.filter(name__regex=query)
+            for d in devices:
+                subgraph.node(d.name)
 
+            # Add an invisible connection to each successive device in a set to enforce horizontal order
+            for j in range(0, len(devices) - 1):
+                subgraph.edge(devices[j].name, devices[j + 1].name, style='invis')
+
+            graph.subgraph(subgraph)
+
+        # Compile list of all devices
+        device_superset = Q()
+        for device_set in tmap.device_sets:
+            for query in device_set.split(';'):  # Split regexes on semicolons
+                device_superset = device_superset | Q(name__regex=query)
+
+        # Add all connections to the graph
+        devices = Device.objects.filter(*(device_superset,))
+        connections = InterfaceConnection.objects.filter(interface_a__device__in=devices,
+                                                         interface_b__device__in=devices)
+        for c in connections:
+            graph.edge(c.interface_a.device.name, c.interface_b.device.name)
+
+        # Get the image data and return
         try:
-            data = tmap.render(img_format=img_format)
+            topo_data = graph.pipe(format='png')
         except:
-            return HttpResponse(
+            return HttpResponse("There was an error generating the requested graph. Ensure that the GraphViz "
-                "There was an error generating the requested graph. Ensure that the GraphViz executables have been "
+                                "executables have been installed correctly.")
-                "installed correctly."
+        response = HttpResponse(topo_data, content_type='image/png')
-            )
-
-        response = HttpResponse(data, content_type='image/{}'.format(img_format))
-        response['Content-Disposition'] = 'inline; filename="{}.{}"'.format(tmap.slug, img_format)
 
         return response
-
-
-class ImageAttachmentViewSet(WritableSerializerMixin, ModelViewSet):
-    queryset = ImageAttachment.objects.all()
-    serializer_class = serializers.ImageAttachmentSerializer
-    write_serializer_class = serializers.WritableImageAttachmentSerializer
-
-
-class RecentActivityViewSet(ReadOnlyModelViewSet):
-    """
-    List all UserActions to provide a log of recent activity.
-    """
-    queryset = UserAction.objects.all()
-    serializer_class = serializers.UserActionSerializer
-    filter_class = filters.UserActionFilter

netbox/extras/constants.py

@@ -1,62 +0,0 @@
-from __future__ import unicode_literals
-
-
-# Models which support custom fields
-CUSTOMFIELD_MODELS = (
-    'site', 'rack', 'devicetype', 'device',                 # DCIM
-    'aggregate', 'prefix', 'ipaddress', 'vlan', 'vrf',      # IPAM
-    'provider', 'circuit',                                  # Circuits
-    'tenant',                                               # Tenants
-)
-
-# Custom field types
-CF_TYPE_TEXT = 100
-CF_TYPE_INTEGER = 200
-CF_TYPE_BOOLEAN = 300
-CF_TYPE_DATE = 400
-CF_TYPE_URL = 500
-CF_TYPE_SELECT = 600
-CUSTOMFIELD_TYPE_CHOICES = (
-    (CF_TYPE_TEXT, 'Text'),
-    (CF_TYPE_INTEGER, 'Integer'),
-    (CF_TYPE_BOOLEAN, 'Boolean (true/false)'),
-    (CF_TYPE_DATE, 'Date'),
-    (CF_TYPE_URL, 'URL'),
-    (CF_TYPE_SELECT, 'Selection'),
-)
-
-# Graph types
-GRAPH_TYPE_INTERFACE = 100
-GRAPH_TYPE_PROVIDER = 200
-GRAPH_TYPE_SITE = 300
-GRAPH_TYPE_CHOICES = (
-    (GRAPH_TYPE_INTERFACE, 'Interface'),
-    (GRAPH_TYPE_PROVIDER, 'Provider'),
-    (GRAPH_TYPE_SITE, 'Site'),
-)
-
-# Models which support export templates
-EXPORTTEMPLATE_MODELS = [
-    'site', 'rack', 'device', 'consoleport', 'powerport', 'interfaceconnection',    # DCIM
-    'aggregate', 'prefix', 'ipaddress', 'vlan',                                     # IPAM
-    'provider', 'circuit',                                                          # Circuits
-    'tenant',                                                                       # Tenants
-]
-
-# User action types
-ACTION_CREATE = 1
-ACTION_IMPORT = 2
-ACTION_EDIT = 3
-ACTION_BULK_EDIT = 4
-ACTION_DELETE = 5
-ACTION_BULK_DELETE = 6
-ACTION_BULK_CREATE = 7
-ACTION_CHOICES = (
-    (ACTION_CREATE, 'created'),
-    (ACTION_BULK_CREATE, 'bulk created'),
-    (ACTION_IMPORT, 'imported'),
-    (ACTION_EDIT, 'modified'),
-    (ACTION_BULK_EDIT, 'bulk edited'),
-    (ACTION_DELETE, 'deleted'),
-    (ACTION_BULK_DELETE, 'bulk deleted'),
-)

netbox/extras/filters.py

@@ -1,12 +1,8 @@
-from __future__ import unicode_literals
-
 import django_filters
 
-from django.contrib.auth.models import User
 from django.contrib.contenttypes.models import ContentType
 
-from dcim.models import Site
+from .models import CF_TYPE_SELECT, CustomField
-from .models import CF_TYPE_SELECT, CustomField, Graph, ExportTemplate, TopologyMap, UserAction
 
 
 class CustomFieldFilter(django_filters.Filter):
@@ -32,7 +28,7 @@ class CustomFieldFilter(django_filters.Filter):
             pass
         return queryset.filter(
             custom_field_values__field__name=self.name,
-            custom_field_values__serialized_value__icontains=value,
+            custom_field_values__serialized_value=value,
         )
 
 
@@ -48,47 +44,3 @@ class CustomFieldFilterSet(django_filters.FilterSet):
         custom_fields = CustomField.objects.filter(obj_type=obj_type, is_filterable=True)
         for cf in custom_fields:
             self.filters['cf_{}'.format(cf.name)] = CustomFieldFilter(name=cf.name, cf_type=cf.type)
-
-
-class GraphFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = Graph
-        fields = ['type', 'name']
-
-
-class ExportTemplateFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = ExportTemplate
-        fields = ['content_type', 'name']
-
-
-class TopologyMapFilter(django_filters.FilterSet):
-    site_id = django_filters.ModelMultipleChoiceFilter(
-        name='site',
-        queryset=Site.objects.all(),
-        label='Site',
-    )
-    site = django_filters.ModelMultipleChoiceFilter(
-        name='site__slug',
-        queryset=Site.objects.all(),
-        to_field_name='slug',
-        label='Site (slug)',
-    )
-
-    class Meta:
-        model = TopologyMap
-        fields = ['name', 'slug']
-
-
-class UserActionFilter(django_filters.FilterSet):
-    username = django_filters.ModelMultipleChoiceFilter(
-        name='user__username',
-        queryset=User.objects.all(),
-        to_field_name='username',
-    )
-
-    class Meta:
-        model = UserAction
-        fields = ['user']

netbox/extras/forms.py

@@ -1,13 +1,11 @@
-from __future__ import unicode_literals
 from collections import OrderedDict
 
 from django import forms
 from django.contrib.contenttypes.models import ContentType
 
-from utilities.forms import BootstrapMixin, BulkEditForm, LaxURLField
+from utilities.forms import BulkEditForm, LaxURLField
 from .models import (
-    CF_TYPE_BOOLEAN, CF_TYPE_DATE, CF_TYPE_INTEGER, CF_TYPE_SELECT, CF_TYPE_URL, CustomField, CustomFieldValue,
+    CF_TYPE_BOOLEAN, CF_TYPE_DATE, CF_TYPE_INTEGER, CF_TYPE_SELECT, CF_TYPE_URL, CustomField, CustomFieldValue
-    ImageAttachment,
 )
 
 
@@ -105,7 +103,7 @@ class CustomFieldForm(forms.ModelForm):
                                                                            obj_id=self.instance.pk)
             except CustomFieldValue.DoesNotExist:
                 # Skip this field if none exists already and its value is empty
-                if self.cleaned_data[field_name] in [None, '']:
+                if self.cleaned_data[field_name] in [None, u'']:
                     continue
                 cfv = CustomFieldValue(
                     field=self.fields[field_name].model,
@@ -160,10 +158,3 @@ class CustomFieldFilterForm(forms.Form):
         for name, field in custom_fields:
             field.required = False
             self.fields[name] = field
-
-
-class ImageAttachmentForm(BootstrapMixin, forms.ModelForm):
-
-    class Meta:
-        model = ImageAttachment
-        fields = ['name', 'image']

netbox/extras/management/commands/nbshell.py

@@ -1,62 +0,0 @@
-from __future__ import unicode_literals
-
-import code
-import platform
-import sys
-
-from django import get_version
-from django.apps import apps
-from django.conf import settings
-from django.core.management.base import BaseCommand
-from django.db.models import Model
-
-
-APPS = ['circuits', 'dcim', 'extras', 'ipam', 'secrets', 'tenancy', 'users']
-
-BANNER_TEXT = """### NetBox interactive shell ({node})
-### Python {python} | Django {django} | NetBox {netbox}
-### lsmodels() will show available models. Use help(<model>) for more info.""".format(
-    node=platform.node(),
-    python=platform.python_version(),
-    django=get_version(),
-    netbox=settings.VERSION
-)
-
-
-class Command(BaseCommand):
-    help = "Start the Django shell with all NetBox models already imported"
-    django_models = {}
-
-    def _lsmodels(self):
-        for app, models in self.django_models.items():
-            app_name = apps.get_app_config(app).verbose_name
-            print('{}:'.format(app_name))
-            for m in models:
-                print('  {}'.format(m))
-
-    def get_namespace(self):
-        namespace = {}
-
-        # Gather Django models from each app
-        for app in APPS:
-            self.django_models[app] = []
-            app_models = sys.modules['{}.models'.format(app)]
-            for name in dir(app_models):
-                model = getattr(app_models, name)
-                try:
-                    if issubclass(model, Model):
-                        namespace[name] = model
-                        self.django_models[app].append(name)
-                except TypeError:
-                    pass
-
-        # Load convenience commands
-        namespace.update({
-            'lsmodels': self._lsmodels,
-        })
-
-        return namespace
-
-    def handle(self, **options):
-        shell = code.interact(banner=BANNER_TEXT, local=self.get_namespace())
-        return shell

netbox/extras/management/commands/run_inventory.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from getpass import getpass
 from ncclient.transport.errors import AuthenticationError
 from paramiko import AuthenticationException
@@ -8,7 +6,7 @@ from django.conf import settings
 from django.core.management.base import BaseCommand, CommandError
 from django.db import transaction
 
-from dcim.models import Device, InventoryItem, Site, STATUS_ACTIVE
+from dcim.models import Device, Module, Site
 
 
 class Command(BaseCommand):
@@ -27,12 +25,12 @@ class Command(BaseCommand):
 
     def handle(self, *args, **options):
 
-        def create_inventory_items(inventory_items, parent=None):
+        def create_modules(modules, parent=None):
-            for item in inventory_items:
+            for module in modules:
-                i = InventoryItem(device=device, parent=parent, name=item['name'], part_id=item['part_id'],
+                m = Module(device=device, parent=parent, name=module['name'], part_id=module['part_id'],
-                                  serial=item['serial'], discovered=True)
+                           serial=module['serial'], discovered=True)
-                i.save()
+                m.save()
-                create_inventory_items(item.get('items', []), parent=i)
+                create_modules(module.get('modules', []), parent=m)
 
         # Credentials
         if options['username']:
@@ -41,7 +39,7 @@ class Command(BaseCommand):
             self.password = getpass("Password: ")
 
         # Attempt to inventory only active devices
-        device_list = Device.objects.filter(status=STATUS_ACTIVE)
+        device_list = Device.objects.filter(status=True)
 
         # --site: Include only devices belonging to specified site(s)
         if options['site']:
@@ -74,7 +72,7 @@ class Command(BaseCommand):
 
             # Skip inactive devices
             if not device.status:
-                self.stdout.write("Skipped (not active)")
+                self.stdout.write("Skipped (inactive)")
                 continue
 
             # Skip devices without primary_ip set
@@ -109,9 +107,9 @@ class Command(BaseCommand):
                 self.stdout.write("")
                 self.stdout.write("\tSerial: {}".format(inventory['chassis']['serial']))
                 self.stdout.write("\tDescription: {}".format(inventory['chassis']['description']))
-                for item in inventory['items']:
+                for module in inventory['modules']:
-                    self.stdout.write("\tItem: {} / {} ({})".format(item['name'], item['part_id'],
+                    self.stdout.write("\tModule: {} / {} ({})".format(module['name'], module['part_id'],
-                                                                    item['serial']))
+                                                                      module['serial']))
             else:
                 self.stdout.write("{} ({})".format(inventory['chassis']['description'], inventory['chassis']['serial']))
 
@@ -121,7 +119,7 @@ class Command(BaseCommand):
                     if device.serial != inventory['chassis']['serial']:
                         device.serial = inventory['chassis']['serial']
                         device.save()
-                    InventoryItem.objects.filter(device=device, discovered=True).delete()
+                    Module.objects.filter(device=device, discovered=True).delete()
-                    create_inventory_items(inventory.get('items', []))
+                    create_modules(inventory.get('modules', []))
 
         self.stdout.write("Finished!")

netbox/extras/migrations/0006_add_imageattachments.py

@@ -1,34 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11 on 2017-04-04 19:58
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-import django.db.models.deletion
-import extras.models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('contenttypes', '0002_remove_content_type_name'),
-        ('extras', '0005_useraction_add_bulk_create'),
-    ]
-
-    operations = [
-        migrations.CreateModel(
-            name='ImageAttachment',
-            fields=[
-                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
-                ('object_id', models.PositiveIntegerField()),
-                ('image', models.ImageField(height_field=b'image_height', upload_to=extras.models.image_upload, width_field=b'image_width')),
-                ('image_height', models.PositiveSmallIntegerField()),
-                ('image_width', models.PositiveSmallIntegerField()),
-                ('name', models.CharField(blank=True, max_length=50)),
-                ('created', models.DateTimeField(auto_now_add=True)),
-                ('content_type', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='contenttypes.ContentType')),
-            ],
-            options={
-                'ordering': ['name'],
-            },
-        ),
-    ]

netbox/extras/migrations/0007_unicode_literals.py

@@ -1,91 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11 on 2017-05-24 15:34
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-import extras.models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('extras', '0006_add_imageattachments'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='customfield',
-            name='default',
-            field=models.CharField(blank=True, help_text='Default value for the field. Use "true" or "false" for booleans. N/A for selection fields.', max_length=100),
-        ),
-        migrations.AlterField(
-            model_name='customfield',
-            name='is_filterable',
-            field=models.BooleanField(default=True, help_text='This field can be used to filter objects.'),
-        ),
-        migrations.AlterField(
-            model_name='customfield',
-            name='label',
-            field=models.CharField(blank=True, help_text="Name of the field as displayed to users (if not provided, the field's name will be used)", max_length=50),
-        ),
-        migrations.AlterField(
-            model_name='customfield',
-            name='obj_type',
-            field=models.ManyToManyField(help_text='The object(s) to which this field applies.', related_name='custom_fields', to='contenttypes.ContentType', verbose_name='Object(s)'),
-        ),
-        migrations.AlterField(
-            model_name='customfield',
-            name='required',
-            field=models.BooleanField(default=False, help_text='Determines whether this field is required when creating new objects or editing an existing object.'),
-        ),
-        migrations.AlterField(
-            model_name='customfield',
-            name='type',
-            field=models.PositiveSmallIntegerField(choices=[(100, 'Text'), (200, 'Integer'), (300, 'Boolean (true/false)'), (400, 'Date'), (500, 'URL'), (600, 'Selection')], default=100),
-        ),
-        migrations.AlterField(
-            model_name='customfield',
-            name='weight',
-            field=models.PositiveSmallIntegerField(default=100, help_text='Fields with higher weights appear lower in a form'),
-        ),
-        migrations.AlterField(
-            model_name='customfieldchoice',
-            name='weight',
-            field=models.PositiveSmallIntegerField(default=100, help_text='Higher weights appear lower in the list'),
-        ),
-        migrations.AlterField(
-            model_name='graph',
-            name='link',
-            field=models.URLField(blank=True, verbose_name='Link URL'),
-        ),
-        migrations.AlterField(
-            model_name='graph',
-            name='name',
-            field=models.CharField(max_length=100, verbose_name='Name'),
-        ),
-        migrations.AlterField(
-            model_name='graph',
-            name='source',
-            field=models.CharField(max_length=500, verbose_name='Source URL'),
-        ),
-        migrations.AlterField(
-            model_name='graph',
-            name='type',
-            field=models.PositiveSmallIntegerField(choices=[(100, 'Interface'), (200, 'Provider'), (300, 'Site')]),
-        ),
-        migrations.AlterField(
-            model_name='imageattachment',
-            name='image',
-            field=models.ImageField(height_field='image_height', upload_to=extras.models.image_upload, width_field='image_width'),
-        ),
-        migrations.AlterField(
-            model_name='topologymap',
-            name='device_patterns',
-            field=models.TextField(help_text='Identify devices to include in the diagram using regular expressions, one per line. Each line will result in a new tier of the drawing. Separate multiple regexes within a line using semicolons. Devices will be rendered in the order they are defined.'),
-        ),
-        migrations.AlterField(
-            model_name='useraction',
-            name='action',
-            field=models.PositiveSmallIntegerField(choices=[(1, 'created'), (7, 'bulk created'), (2, 'imported'), (3, 'modified'), (4, 'bulk edited'), (5, 'deleted'), (6, 'bulk deleted')]),
-        ),
-    ]

netbox/extras/models.py

@@ -1,26 +1,72 @@
-from __future__ import unicode_literals
 from collections import OrderedDict
 from datetime import date
-import graphviz
 
 from django.contrib.auth.models import User
 from django.contrib.contenttypes.fields import GenericForeignKey
 from django.contrib.contenttypes.models import ContentType
 from django.core.validators import ValidationError
 from django.db import models
-from django.db.models import Q
 from django.http import HttpResponse
 from django.template import Template, Context
 from django.utils.encoding import python_2_unicode_compatible
 from django.utils.safestring import mark_safe
 
-from utilities.utils import foreground_color
-from .constants import *
 
+CUSTOMFIELD_MODELS = (
+    'site', 'rack', 'devicetype', 'device',                 # DCIM
+    'aggregate', 'prefix', 'ipaddress', 'vlan', 'vrf',      # IPAM
+    'provider', 'circuit',                                  # Circuits
+    'tenant',                                               # Tenants
+)
+
+CF_TYPE_TEXT = 100
+CF_TYPE_INTEGER = 200
+CF_TYPE_BOOLEAN = 300
+CF_TYPE_DATE = 400
+CF_TYPE_URL = 500
+CF_TYPE_SELECT = 600
+CUSTOMFIELD_TYPE_CHOICES = (
+    (CF_TYPE_TEXT, 'Text'),
+    (CF_TYPE_INTEGER, 'Integer'),
+    (CF_TYPE_BOOLEAN, 'Boolean (true/false)'),
+    (CF_TYPE_DATE, 'Date'),
+    (CF_TYPE_URL, 'URL'),
+    (CF_TYPE_SELECT, 'Selection'),
+)
+
+GRAPH_TYPE_INTERFACE = 100
+GRAPH_TYPE_PROVIDER = 200
+GRAPH_TYPE_SITE = 300
+GRAPH_TYPE_CHOICES = (
+    (GRAPH_TYPE_INTERFACE, 'Interface'),
+    (GRAPH_TYPE_PROVIDER, 'Provider'),
+    (GRAPH_TYPE_SITE, 'Site'),
+)
+
+EXPORTTEMPLATE_MODELS = [
+    'site', 'rack', 'device', 'consoleport', 'powerport', 'interfaceconnection',    # DCIM
+    'aggregate', 'prefix', 'ipaddress', 'vlan',                                     # IPAM
+    'provider', 'circuit',                                                          # Circuits
+    'tenant',                                                                       # Tenants
+]
+
+ACTION_CREATE = 1
+ACTION_IMPORT = 2
+ACTION_EDIT = 3
+ACTION_BULK_EDIT = 4
+ACTION_DELETE = 5
+ACTION_BULK_DELETE = 6
+ACTION_BULK_CREATE = 7
+ACTION_CHOICES = (
+    (ACTION_CREATE, 'created'),
+    (ACTION_BULK_CREATE, 'bulk created'),
+    (ACTION_IMPORT, 'imported'),
+    (ACTION_EDIT, 'modified'),
+    (ACTION_BULK_EDIT, 'bulk edited'),
+    (ACTION_DELETE, 'deleted'),
+    (ACTION_BULK_DELETE, 'bulk deleted'),
+)
 
-#
-# Custom fields
-#
 
 class CustomFieldModel(object):
 
@@ -84,11 +130,7 @@ class CustomField(models.Model):
         if self.type == CF_TYPE_BOOLEAN:
             return str(int(bool(value)))
         if self.type == CF_TYPE_DATE:
-            # Could be date/datetime object or string
-            try:
             return value.strftime('%Y-%m-%d')
-            except AttributeError:
-                return value
         if self.type == CF_TYPE_SELECT:
             # Could be ModelChoiceField or TypedChoiceField
             return str(value.id) if hasattr(value, 'id') else str(value)
@@ -108,13 +150,16 @@ class CustomField(models.Model):
             # Read date as YYYY-MM-DD
             return date(*[int(n) for n in serialized_value.split('-')])
         if self.type == CF_TYPE_SELECT:
+            try:
                 return self.choices.get(pk=int(serialized_value))
+            except CustomFieldChoice.DoesNotExist:
+                return None
         return serialized_value
 
 
 @python_2_unicode_compatible
 class CustomFieldValue(models.Model):
-    field = models.ForeignKey('CustomField', related_name='values', on_delete=models.CASCADE)
+    field = models.ForeignKey('CustomField', related_name='values')
     obj_type = models.ForeignKey(ContentType, related_name='+', on_delete=models.PROTECT)
     obj_id = models.PositiveIntegerField()
     obj = GenericForeignKey('obj_type', 'obj_id')
@@ -125,7 +170,7 @@ class CustomFieldValue(models.Model):
         unique_together = ['field', 'obj_type', 'obj_id']
 
     def __str__(self):
-        return '{} {}'.format(self.obj, self.field)
+        return u'{} {}'.format(self.obj, self.field)
 
     @property
     def value(self):
@@ -168,10 +213,6 @@ class CustomFieldChoice(models.Model):
         CustomFieldValue.objects.filter(field__type=CF_TYPE_SELECT, serialized_value=str(pk)).delete()
 
 
-#
-# Graphs
-#
-
 @python_2_unicode_compatible
 class Graph(models.Model):
     type = models.PositiveSmallIntegerField(choices=GRAPH_TYPE_CHOICES)
@@ -197,15 +238,9 @@ class Graph(models.Model):
         return template.render(Context({'obj': obj}))
 
 
-#
-# Export templates
-#
-
 @python_2_unicode_compatible
 class ExportTemplate(models.Model):
-    content_type = models.ForeignKey(
+    content_type = models.ForeignKey(ContentType, limit_choices_to={'model__in': EXPORTTEMPLATE_MODELS})
-        ContentType, limit_choices_to={'model__in': EXPORTTEMPLATE_MODELS}, on_delete=models.CASCADE
-    )
     name = models.CharField(max_length=100)
     description = models.CharField(max_length=200, blank=True)
     template_code = models.TextField()
@@ -219,7 +254,7 @@ class ExportTemplate(models.Model):
         ]
 
     def __str__(self):
-        return '{}: {}'.format(self.content_type, self.name)
+        return u'{}: {}'.format(self.content_type, self.name)
 
     def to_response(self, context_dict, filename):
         """
@@ -237,15 +272,11 @@ class ExportTemplate(models.Model):
         return response
 
 
-#
-# Topology maps
-#
-
 @python_2_unicode_compatible
 class TopologyMap(models.Model):
     name = models.CharField(max_length=50, unique=True)
     slug = models.SlugField(unique=True)
-    site = models.ForeignKey('dcim.Site', related_name='topology_maps', blank=True, null=True, on_delete=models.CASCADE)
+    site = models.ForeignKey('dcim.Site', related_name='topology_maps', blank=True, null=True)
     device_patterns = models.TextField(
         help_text="Identify devices to include in the diagram using regular expressions, one per line. Each line will "
                   "result in a new tier of the drawing. Separate multiple regexes within a line using semicolons. "
@@ -265,132 +296,6 @@ class TopologyMap(models.Model):
             return None
         return [line.strip() for line in self.device_patterns.split('\n')]
 
-    def render(self, img_format='png'):
-
-        from circuits.models import CircuitTermination
-        from dcim.models import CONNECTION_STATUS_CONNECTED, Device, InterfaceConnection
-
-        # Construct the graph
-        graph = graphviz.Graph()
-        graph.graph_attr['ranksep'] = '1'
-        for i, device_set in enumerate(self.device_sets):
-
-            subgraph = graphviz.Graph(name='sg{}'.format(i))
-            subgraph.graph_attr['rank'] = 'same'
-
-            # Add a pseudonode for each device_set to enforce hierarchical layout
-            subgraph.node('set{}'.format(i), label='', shape='none', width='0')
-            if i:
-                graph.edge('set{}'.format(i - 1), 'set{}'.format(i), style='invis')
-
-            # Add each device to the graph
-            devices = []
-            for query in device_set.split(';'):  # Split regexes on semicolons
-                devices += Device.objects.filter(name__regex=query).select_related('device_role')
-            for d in devices:
-                bg_color = '#{}'.format(d.device_role.color)
-                fg_color = '#{}'.format(foreground_color(d.device_role.color))
-                subgraph.node(d.name, style='filled', fillcolor=bg_color, fontcolor=fg_color, fontname='sans')
-
-            # Add an invisible connection to each successive device in a set to enforce horizontal order
-            for j in range(0, len(devices) - 1):
-                subgraph.edge(devices[j].name, devices[j + 1].name, style='invis')
-
-            graph.subgraph(subgraph)
-
-        # Compile list of all devices
-        device_superset = Q()
-        for device_set in self.device_sets:
-            for query in device_set.split(';'):  # Split regexes on semicolons
-                device_superset = device_superset | Q(name__regex=query)
-
-        # Add all interface connections to the graph
-        devices = Device.objects.filter(*(device_superset,))
-        connections = InterfaceConnection.objects.filter(
-            interface_a__device__in=devices, interface_b__device__in=devices
-        )
-        for c in connections:
-            style = 'solid' if c.connection_status == CONNECTION_STATUS_CONNECTED else 'dashed'
-            graph.edge(c.interface_a.device.name, c.interface_b.device.name, style=style)
-
-        # Add all circuits to the graph
-        for termination in CircuitTermination.objects.filter(term_side='A', interface__device__in=devices):
-            peer_termination = termination.get_peer_termination()
-            if (peer_termination is not None and peer_termination.interface is not None and
-                    peer_termination.interface.device in devices):
-                graph.edge(termination.interface.device.name, peer_termination.interface.device.name, color='blue')
-
-        return graph.pipe(format=img_format)
-
-
-#
-# Image attachments
-#
-
-def image_upload(instance, filename):
-
-    path = 'image-attachments/'
-
-    # Rename the file to the provided name, if any. Attempt to preserve the file extension.
-    extension = filename.rsplit('.')[-1].lower()
-    if instance.name and extension in ['bmp', 'gif', 'jpeg', 'jpg', 'png']:
-        filename = '.'.join([instance.name, extension])
-    elif instance.name:
-        filename = instance.name
-
-    return '{}{}_{}_{}'.format(path, instance.content_type.name, instance.object_id, filename)
-
-
-@python_2_unicode_compatible
-class ImageAttachment(models.Model):
-    """
-    An uploaded image which is associated with an object.
-    """
-    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)
-    object_id = models.PositiveIntegerField()
-    parent = GenericForeignKey('content_type', 'object_id')
-    image = models.ImageField(upload_to=image_upload, height_field='image_height', width_field='image_width')
-    image_height = models.PositiveSmallIntegerField()
-    image_width = models.PositiveSmallIntegerField()
-    name = models.CharField(max_length=50, blank=True)
-    created = models.DateTimeField(auto_now_add=True)
-
-    class Meta:
-        ordering = ['name']
-
-    def __str__(self):
-        if self.name:
-            return self.name
-        filename = self.image.name.rsplit('/', 1)[-1]
-        return filename.split('_', 2)[2]
-
-    def delete(self, *args, **kwargs):
-
-        _name = self.image.name
-
-        super(ImageAttachment, self).delete(*args, **kwargs)
-
-        # Delete file from disk
-        self.image.delete(save=False)
-
-        # Deleting the file erases its name. We restore the image's filename here in case we still need to reference it
-        # before the request finishes. (For example, to display a message indicating the ImageAttachment was deleted.)
-        self.image.name = _name
-
-    @property
-    def size(self):
-        """
-        Wrapper around `image.size` to suppress an OSError in case the file is inaccessible.
-        """
-        try:
-            return self.image.size
-        except OSError:
-            return None
-
-
-#
-# User actions
-#
 
 class UserActionManager(models.Manager):
 
@@ -454,8 +359,8 @@ class UserAction(models.Model):
 
     def __str__(self):
         if self.message:
-            return '{} {}'.format(self.user, self.message)
+            return u'{} {}'.format(self.user, self.message)
-        return '{} {} {}'.format(self.user, self.get_action_display(), self.content_type)
+        return u'{} {} {}'.format(self.user, self.get_action_display(), self.content_type)
 
     def icon(self):
         if self.action in [ACTION_CREATE, ACTION_BULK_CREATE, ACTION_IMPORT]:

netbox/extras/rpc.py

@@ -1,10 +1,8 @@
-from __future__ import unicode_literals
-import re
-import time
-
 from ncclient import manager
 import paramiko
+import re
 import xmltodict
+import time
 
 
 CONNECT_TIMEOUT = 5  # seconds
@@ -35,14 +33,14 @@ class RPCClient(object):
 
     def get_inventory(self):
         """
-        Returns a dictionary representing the device chassis and installed inventory items.
+        Returns a dictionary representing the device chassis and installed modules.
 
         {
             'chassis': {
                 'serial': <str>,
                 'description': <str>,
             }
-            'items': [
+            'modules': [
                 {
                     'name': <str>,
                     'part_id': <str>,
@@ -132,11 +130,8 @@ class JunosNC(RPCClient):
         for neighbor_raw in lldp_neighbors_raw:
             neighbor = dict()
             neighbor['local-interface'] = neighbor_raw.get('lldp-local-port-id')
-            name = neighbor_raw.get('lldp-remote-system-name')
+            neighbor['name'] = neighbor_raw.get('lldp-remote-system-name')
-            if name:
+            neighbor['name'] = neighbor['name'].split('.')[0]  # Split hostname from domain if one is present
-                neighbor['name'] = name.split('.')[0]  # Split hostname from domain if one is present
-            else:
-                neighbor['name'] = ''
             try:
                 neighbor['remote-interface'] = neighbor_raw['lldp-remote-port-description']
             except KeyError:
@@ -149,23 +144,23 @@ class JunosNC(RPCClient):
 
     def get_inventory(self):
 
-        def glean_items(node, depth=0):
+        def glean_modules(node, depth=0):
-            items = []
+            modules = []
-            items_list = node.get('chassis{}-module'.format('-sub' * depth), [])
+            modules_list = node.get('chassis{}-module'.format('-sub' * depth), [])
             # Junos like to return single children directly instead of as a single-item list
-            if hasattr(items_list, 'items'):
+            if hasattr(modules_list, 'items'):
-                items_list = [items_list]
+                modules_list = [modules_list]
-            for item in items_list:
+            for module in modules_list:
                 m = {
-                    'name': item['name'],
+                    'name': module['name'],
-                    'part_id': item.get('model-number') or item.get('part-number', ''),
+                    'part_id': module.get('model-number') or module.get('part-number', ''),
-                    'serial': item.get('serial-number', ''),
+                    'serial': module.get('serial-number', ''),
                 }
-                child_items = glean_items(item, depth + 1)
+                submodules = glean_modules(module, depth + 1)
-                if child_items:
+                if submodules:
-                    m['items'] = child_items
+                    m['modules'] = submodules
-                items.append(m)
+                modules.append(m)
-            return items
+            return modules
 
         rpc_reply = self.manager.dispatch('get-chassis-inventory')
         inventory_raw = xmltodict.parse(rpc_reply.xml)['rpc-reply']['chassis-inventory']['chassis']
@@ -178,8 +173,8 @@ class JunosNC(RPCClient):
             'description': inventory_raw['description'],
         }
 
-        # Gather inventory items
+        # Gather modules
-        result['items'] = glean_items(inventory_raw)
+        result['modules'] = glean_modules(inventory_raw)
 
         return result
 
@@ -204,7 +199,7 @@ class IOSSSH(SSHClient):
                 'description': parse(sh_ver, 'cisco ([^\s]+)')
             }
 
-        def items(chassis_serial=None):
+        def modules(chassis_serial=None):
             cmd = self._send('show inventory').split('\r\n\r\n')
             for i in cmd:
                 i_fmt = i.replace('\r\n', ' ')
@@ -212,7 +207,7 @@ class IOSSSH(SSHClient):
                     m_name = re.search('NAME: "([^"]+)"', i_fmt).group(1)
                     m_pid = re.search('PID: ([^\s]+)', i_fmt).group(1)
                     m_serial = re.search('SN: ([^\s]+)', i_fmt).group(1)
-                    # Omit built-in items and those with no PID
+                    # Omit built-in modules and those with no PID
                     if m_serial != chassis_serial and m_pid.lower() != 'unspecified':
                         yield {
                             'name': m_name,
@@ -227,7 +222,7 @@ class IOSSSH(SSHClient):
 
         return {
             'chassis': sh_version,
-            'items': list(items(chassis_serial=sh_version.get('serial')))
+            'modules': list(modules(chassis_serial=sh_version.get('serial')))
         }
 
 
@@ -262,7 +257,7 @@ class OpengearSSH(SSHClient):
                 'serial': serial,
                 'description': description,
             },
-            'items': [],
+            'modules': [],
         }
 
 

netbox/extras/tests/test_api.py

@@ -1,170 +0,0 @@
-from __future__ import unicode_literals
-
-from rest_framework import status
-from rest_framework.test import APITestCase
-
-from django.contrib.auth.models import User
-from django.contrib.contenttypes.models import ContentType
-from django.urls import reverse
-
-from dcim.models import Device
-from extras.models import Graph, GRAPH_TYPE_SITE, ExportTemplate
-from users.models import Token
-from utilities.tests import HttpStatusMixin
-
-
-class GraphTest(HttpStatusMixin, APITestCase):
-
-    def setUp(self):
-
-        user = User.objects.create(username='testuser', is_superuser=True)
-        token = Token.objects.create(user=user)
-        self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
-
-        self.graph1 = Graph.objects.create(
-            type=GRAPH_TYPE_SITE, name='Test Graph 1', source='http://example.com/graphs.py?site={{ obj.name }}&foo=1'
-        )
-        self.graph2 = Graph.objects.create(
-            type=GRAPH_TYPE_SITE, name='Test Graph 2', source='http://example.com/graphs.py?site={{ obj.name }}&foo=2'
-        )
-        self.graph3 = Graph.objects.create(
-            type=GRAPH_TYPE_SITE, name='Test Graph 3', source='http://example.com/graphs.py?site={{ obj.name }}&foo=3'
-        )
-
-    def test_get_graph(self):
-
-        url = reverse('extras-api:graph-detail', kwargs={'pk': self.graph1.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['name'], self.graph1.name)
-
-    def test_list_graphs(self):
-
-        url = reverse('extras-api:graph-list')
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['count'], 3)
-
-    def test_create_graph(self):
-
-        data = {
-            'type': GRAPH_TYPE_SITE,
-            'name': 'Test Graph 4',
-            'source': 'http://example.com/graphs.py?site={{ obj.name }}&foo=4',
-        }
-
-        url = reverse('extras-api:graph-list')
-        response = self.client.post(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(Graph.objects.count(), 4)
-        graph4 = Graph.objects.get(pk=response.data['id'])
-        self.assertEqual(graph4.type, data['type'])
-        self.assertEqual(graph4.name, data['name'])
-        self.assertEqual(graph4.source, data['source'])
-
-    def test_update_graph(self):
-
-        data = {
-            'type': GRAPH_TYPE_SITE,
-            'name': 'Test Graph X',
-            'source': 'http://example.com/graphs.py?site={{ obj.name }}&foo=99',
-        }
-
-        url = reverse('extras-api:graph-detail', kwargs={'pk': self.graph1.pk})
-        response = self.client.put(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(Graph.objects.count(), 3)
-        graph1 = Graph.objects.get(pk=response.data['id'])
-        self.assertEqual(graph1.type, data['type'])
-        self.assertEqual(graph1.name, data['name'])
-        self.assertEqual(graph1.source, data['source'])
-
-    def test_delete_graph(self):
-
-        url = reverse('extras-api:graph-detail', kwargs={'pk': self.graph1.pk})
-        response = self.client.delete(url, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(Graph.objects.count(), 2)
-
-
-class ExportTemplateTest(HttpStatusMixin, APITestCase):
-
-    def setUp(self):
-
-        user = User.objects.create(username='testuser', is_superuser=True)
-        token = Token.objects.create(user=user)
-        self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
-
-        self.content_type = ContentType.objects.get_for_model(Device)
-        self.exporttemplate1 = ExportTemplate.objects.create(
-            content_type=self.content_type, name='Test Export Template 1',
-            template_code='{% for obj in queryset %}{{ obj.name }}\n{% endfor %}'
-        )
-        self.exporttemplate2 = ExportTemplate.objects.create(
-            content_type=self.content_type, name='Test Export Template 2',
-            template_code='{% for obj in queryset %}{{ obj.name }}\n{% endfor %}'
-        )
-        self.exporttemplate3 = ExportTemplate.objects.create(
-            content_type=self.content_type, name='Test Export Template 3',
-            template_code='{% for obj in queryset %}{{ obj.name }}\n{% endfor %}'
-        )
-
-    def test_get_exporttemplate(self):
-
-        url = reverse('extras-api:exporttemplate-detail', kwargs={'pk': self.exporttemplate1.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['name'], self.exporttemplate1.name)
-
-    def test_list_exporttemplates(self):
-
-        url = reverse('extras-api:exporttemplate-list')
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['count'], 3)
-
-    def test_create_exporttemplate(self):
-
-        data = {
-            'content_type': self.content_type.pk,
-            'name': 'Test Export Template 4',
-            'template_code': '{% for obj in queryset %}{{ obj.name }}\n{% endfor %}',
-        }
-
-        url = reverse('extras-api:exporttemplate-list')
-        response = self.client.post(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_201_CREATED)
-        self.assertEqual(ExportTemplate.objects.count(), 4)
-        exporttemplate4 = ExportTemplate.objects.get(pk=response.data['id'])
-        self.assertEqual(exporttemplate4.content_type_id, data['content_type'])
-        self.assertEqual(exporttemplate4.name, data['name'])
-        self.assertEqual(exporttemplate4.template_code, data['template_code'])
-
-    def test_update_exporttemplate(self):
-
-        data = {
-            'content_type': self.content_type.pk,
-            'name': 'Test Export Template X',
-            'template_code': '{% for obj in queryset %}{{ obj.name }}\n{% endfor %}',
-        }
-
-        url = reverse('extras-api:exporttemplate-detail', kwargs={'pk': self.exporttemplate1.pk})
-        response = self.client.put(url, data, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(ExportTemplate.objects.count(), 3)
-        exporttemplate1 = ExportTemplate.objects.get(pk=response.data['id'])
-        self.assertEqual(exporttemplate1.name, data['name'])
-        self.assertEqual(exporttemplate1.template_code, data['template_code'])
-
-    def test_delete_exporttemplate(self):
-
-        url = reverse('extras-api:exporttemplate-detail', kwargs={'pk': self.exporttemplate1.pk})
-        response = self.client.delete(url, **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_204_NO_CONTENT)
-        self.assertEqual(ExportTemplate.objects.count(), 2)

netbox/extras/tests/test_customfields.py

@@ -1,24 +1,17 @@
-from __future__ import unicode_literals
 from datetime import date
 
-from rest_framework import status
-from rest_framework.test import APITestCase
-
-from django.contrib.auth.models import User
 from django.contrib.contenttypes.models import ContentType
 from django.test import TestCase
-from django.urls import reverse
 
 from dcim.models import Site
+
 from extras.models import (
     CustomField, CustomFieldValue, CustomFieldChoice, CF_TYPE_TEXT, CF_TYPE_INTEGER, CF_TYPE_BOOLEAN, CF_TYPE_DATE,
     CF_TYPE_SELECT, CF_TYPE_URL,
 )
-from users.models import Token
-from utilities.tests import HttpStatusMixin
 
 
-class CustomFieldTest(TestCase):
+class CustomFieldTestCase(TestCase):
 
     def setUp(self):
 
@@ -102,209 +95,3 @@ class CustomFieldTest(TestCase):
 
         # Delete the custom field
         cf.delete()
-
-
-class CustomFieldAPITest(HttpStatusMixin, APITestCase):
-
-    def setUp(self):
-
-        user = User.objects.create(username='testuser', is_superuser=True)
-        token = Token.objects.create(user=user)
-        self.header = {'HTTP_AUTHORIZATION': 'Token {}'.format(token.key)}
-
-        content_type = ContentType.objects.get_for_model(Site)
-
-        # Text custom field
-        self.cf_text = CustomField(type=CF_TYPE_TEXT, name='magic_word')
-        self.cf_text.save()
-        self.cf_text.obj_type = [content_type]
-        self.cf_text.save()
-
-        # Integer custom field
-        self.cf_integer = CustomField(type=CF_TYPE_INTEGER, name='magic_number')
-        self.cf_integer.save()
-        self.cf_integer.obj_type = [content_type]
-        self.cf_integer.save()
-
-        # Boolean custom field
-        self.cf_boolean = CustomField(type=CF_TYPE_BOOLEAN, name='is_magic')
-        self.cf_boolean.save()
-        self.cf_boolean.obj_type = [content_type]
-        self.cf_boolean.save()
-
-        # Date custom field
-        self.cf_date = CustomField(type=CF_TYPE_DATE, name='magic_date')
-        self.cf_date.save()
-        self.cf_date.obj_type = [content_type]
-        self.cf_date.save()
-
-        # URL custom field
-        self.cf_url = CustomField(type=CF_TYPE_URL, name='magic_url')
-        self.cf_url.save()
-        self.cf_url.obj_type = [content_type]
-        self.cf_url.save()
-
-        # Select custom field
-        self.cf_select = CustomField(type=CF_TYPE_SELECT, name='magic_choice')
-        self.cf_select.save()
-        self.cf_select.obj_type = [content_type]
-        self.cf_select.save()
-        self.cf_select_choice1 = CustomFieldChoice(field=self.cf_select, value='Foo')
-        self.cf_select_choice1.save()
-        self.cf_select_choice2 = CustomFieldChoice(field=self.cf_select, value='Bar')
-        self.cf_select_choice2.save()
-        self.cf_select_choice3 = CustomFieldChoice(field=self.cf_select, value='Baz')
-        self.cf_select_choice3.save()
-
-        self.site = Site.objects.create(name='Test Site 1', slug='test-site-1')
-
-    def test_get_obj_without_custom_fields(self):
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['name'], self.site.name)
-        self.assertEqual(response.data['custom_fields'], {
-            'magic_word': None,
-            'magic_number': None,
-            'is_magic': None,
-            'magic_date': None,
-            'magic_url': None,
-            'magic_choice': None,
-        })
-
-    def test_get_obj_with_custom_fields(self):
-
-        CUSTOM_FIELD_VALUES = [
-            (self.cf_text, 'Test string'),
-            (self.cf_integer, 1234),
-            (self.cf_boolean, True),
-            (self.cf_date, date(2016, 6, 23)),
-            (self.cf_url, 'http://example.com/'),
-            (self.cf_select, self.cf_select_choice1.pk),
-        ]
-        for field, value in CUSTOM_FIELD_VALUES:
-            cfv = CustomFieldValue(field=field, obj=self.site)
-            cfv.value = value
-            cfv.save()
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.get(url, **self.header)
-
-        self.assertEqual(response.data['name'], self.site.name)
-        self.assertEqual(response.data['custom_fields'].get('magic_word'), CUSTOM_FIELD_VALUES[0][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_number'), CUSTOM_FIELD_VALUES[1][1])
-        self.assertEqual(response.data['custom_fields'].get('is_magic'), CUSTOM_FIELD_VALUES[2][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_date'), CUSTOM_FIELD_VALUES[3][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_url'), CUSTOM_FIELD_VALUES[4][1])
-        self.assertEqual(response.data['custom_fields'].get('magic_choice'), {
-            'value': self.cf_select_choice1.pk, 'label': 'Foo'
-        })
-
-    def test_set_custom_field_text(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_word': 'Foo bar baz',
-            }
-        }
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_word'), data['custom_fields']['magic_word'])
-        cfv = self.site.custom_field_values.get(field=self.cf_text)
-        self.assertEqual(cfv.value, data['custom_fields']['magic_word'])
-
-    def test_set_custom_field_integer(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_number': 42,
-            }
-        }
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_number'), data['custom_fields']['magic_number'])
-        cfv = self.site.custom_field_values.get(field=self.cf_integer)
-        self.assertEqual(cfv.value, data['custom_fields']['magic_number'])
-
-    def test_set_custom_field_boolean(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'is_magic': 0,
-            }
-        }
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('is_magic'), data['custom_fields']['is_magic'])
-        cfv = self.site.custom_field_values.get(field=self.cf_boolean)
-        self.assertEqual(cfv.value, data['custom_fields']['is_magic'])
-
-    def test_set_custom_field_date(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_date': '2017-04-25',
-            }
-        }
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_date'), data['custom_fields']['magic_date'])
-        cfv = self.site.custom_field_values.get(field=self.cf_date)
-        self.assertEqual(cfv.value.isoformat(), data['custom_fields']['magic_date'])
-
-    def test_set_custom_field_url(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_url': 'http://example.com/2/',
-            }
-        }
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_url'), data['custom_fields']['magic_url'])
-        cfv = self.site.custom_field_values.get(field=self.cf_url)
-        self.assertEqual(cfv.value, data['custom_fields']['magic_url'])
-
-    def test_set_custom_field_select(self):
-
-        data = {
-            'name': 'Test Site 1',
-            'slug': 'test-site-1',
-            'custom_fields': {
-                'magic_choice': self.cf_select_choice2.pk,
-            }
-        }
-
-        url = reverse('dcim-api:site-detail', kwargs={'pk': self.site.pk})
-        response = self.client.put(url, data, format='json', **self.header)
-
-        self.assertHttpStatus(response, status.HTTP_200_OK)
-        self.assertEqual(response.data['custom_fields'].get('magic_choice'), data['custom_fields']['magic_choice'])
-        cfv = self.site.custom_field_values.get(field=self.cf_select)
-        self.assertEqual(cfv.value.pk, data['custom_fields']['magic_choice'])

netbox/extras/urls.py

@@ -1,15 +0,0 @@
-from __future__ import unicode_literals
-
-from django.conf.urls import url
-
-from extras import views
-
-
-app_name = 'extras'
-urlpatterns = [
-
-    # Image attachments
-    url(r'^image-attachments/(?P<pk>\d+)/edit/$', views.ImageAttachmentEditView.as_view(), name='imageattachment_edit'),
-    url(r'^image-attachments/(?P<pk>\d+)/delete/$', views.ImageAttachmentDeleteView.as_view(), name='imageattachment_delete'),
-
-]

netbox/extras/views.py

@@ -1,32 +0,0 @@
-from __future__ import unicode_literals
-
-from django.contrib.auth.mixins import PermissionRequiredMixin
-from django.shortcuts import get_object_or_404
-
-from utilities.views import ObjectDeleteView, ObjectEditView
-from .forms import ImageAttachmentForm
-from .models import ImageAttachment
-
-
-class ImageAttachmentEditView(PermissionRequiredMixin, ObjectEditView):
-    permission_required = 'extras.change_imageattachment'
-    model = ImageAttachment
-    form_class = ImageAttachmentForm
-
-    def alter_obj(self, imageattachment, request, args, kwargs):
-        if not imageattachment.pk:
-            # Assign the parent object based on URL kwargs
-            model = kwargs.get('model')
-            imageattachment.parent = get_object_or_404(model, pk=kwargs['object_id'])
-        return imageattachment
-
-    def get_return_url(self, request, imageattachment):
-        return imageattachment.parent.get_absolute_url()
-
-
-class ImageAttachmentDeleteView(PermissionRequiredMixin, ObjectDeleteView):
-    permission_required = 'extras.delete_imageattachment'
-    model = ImageAttachment
-
-    def get_return_url(self, request, imageattachment):
-        return imageattachment.parent.get_absolute_url()

netbox/generate_secret_key.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 # This script will generate a random 50-character string suitable for use as a SECRET_KEY.
+import os
 import random
 
 charset = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*(-_=+)'
-secure_random = random.SystemRandom()
+random.seed = (os.urandom(2048))
-print(''.join(secure_random.sample(charset, 50)))
+print(''.join(random.choice(charset) for c in range(50)))

netbox/ipam/admin.py

@@ -0,0 +1,81 @@
+from django.contrib import admin
+
+from .models import (
+    Aggregate, IPAddress, Prefix, RIR, Role, VLAN, VLANGroup, VRF,
+)
+
+
+@admin.register(VRF)
+class VRFAdmin(admin.ModelAdmin):
+    list_display = ['name', 'rd', 'tenant', 'enforce_unique']
+    list_filter = ['tenant']
+
+    def get_queryset(self, request):
+        qs = super(VRFAdmin, self).get_queryset(request)
+        return qs.select_related('tenant')
+
+
+@admin.register(Role)
+class RoleAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+    list_display = ['name', 'slug', 'weight']
+
+
+@admin.register(RIR)
+class RIRAdmin(admin.ModelAdmin):
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+    list_display = ['name', 'slug', 'is_private']
+
+
+@admin.register(Aggregate)
+class AggregateAdmin(admin.ModelAdmin):
+    list_display = ['prefix', 'rir', 'date_added']
+    list_filter = ['family', 'rir']
+    search_fields = ['prefix']
+
+
+@admin.register(Prefix)
+class PrefixAdmin(admin.ModelAdmin):
+    list_display = ['prefix', 'vrf', 'tenant', 'site', 'status', 'role', 'vlan']
+    list_filter = ['family', 'site', 'status', 'role']
+    search_fields = ['prefix']
+
+    def get_queryset(self, request):
+        qs = super(PrefixAdmin, self).get_queryset(request)
+        return qs.select_related('vrf', 'site', 'role', 'vlan')
+
+
+@admin.register(IPAddress)
+class IPAddressAdmin(admin.ModelAdmin):
+    list_display = ['address', 'vrf', 'tenant', 'nat_inside']
+    list_filter = ['family']
+    fields = ['address', 'vrf', 'device', 'interface', 'nat_inside']
+    readonly_fields = ['interface', 'device', 'nat_inside']
+    search_fields = ['address']
+
+    def get_queryset(self, request):
+        qs = super(IPAddressAdmin, self).get_queryset(request)
+        return qs.select_related('vrf', 'nat_inside')
+
+
+@admin.register(VLANGroup)
+class VLANGroupAdmin(admin.ModelAdmin):
+    list_display = ['name', 'site', 'slug']
+    prepopulated_fields = {
+        'slug': ['name'],
+    }
+
+
+@admin.register(VLAN)
+class VLANAdmin(admin.ModelAdmin):
+    list_display = ['site', 'vid', 'name', 'tenant', 'status', 'role']
+    list_filter = ['site', 'tenant', 'status', 'role']
+    search_fields = ['vid', 'name']
+
+    def get_queryset(self, request):
+        qs = super(VLANAdmin, self).get_queryset(request)
+        return qs.select_related('site', 'tenant', 'role')

netbox/ipam/api/serializers.py

@@ -1,109 +1,88 @@
-from __future__ import unicode_literals
-from collections import OrderedDict
-
 from rest_framework import serializers
-from rest_framework.validators import UniqueTogetherValidator
 
-from dcim.api.serializers import NestedDeviceSerializer, InterfaceSerializer, NestedSiteSerializer
+from dcim.api.serializers import DeviceNestedSerializer, InterfaceNestedSerializer, SiteNestedSerializer
-from extras.api.customfields import CustomFieldModelSerializer
+from extras.api.serializers import CustomFieldSerializer
-from ipam.models import (
+from ipam.models import Aggregate, IPAddress, Prefix, RIR, Role, Service, VLAN, VLANGroup, VRF
-    Aggregate, IPAddress, IPADDRESS_ROLE_CHOICES, IPADDRESS_STATUS_CHOICES, IP_PROTOCOL_CHOICES, Prefix,
+from tenancy.api.serializers import TenantNestedSerializer
-    PREFIX_STATUS_CHOICES, RIR, Role, Service, VLAN, VLAN_STATUS_CHOICES, VLANGroup, VRF,
-)
-from tenancy.api.serializers import NestedTenantSerializer
-from utilities.api import ChoiceFieldSerializer, ModelValidationMixin
 
 
 #
 # VRFs
 #
 
-class VRFSerializer(CustomFieldModelSerializer):
+class VRFSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    tenant = NestedTenantSerializer()
+    tenant = TenantNestedSerializer()
-
-    class Meta:
-        model = VRF
-        fields = ['id', 'name', 'rd', 'tenant', 'enforce_unique', 'description', 'display_name', 'custom_fields']
-
-
-class NestedVRFSerializer(serializers.ModelSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:vrf-detail')
-
-    class Meta:
-        model = VRF
-        fields = ['id', 'url', 'name', 'rd']
-
-
-class WritableVRFSerializer(CustomFieldModelSerializer):
 
     class Meta:
         model = VRF
         fields = ['id', 'name', 'rd', 'tenant', 'enforce_unique', 'description', 'custom_fields']
 
 
+class VRFNestedSerializer(VRFSerializer):
+
+    class Meta(VRFSerializer.Meta):
+        fields = ['id', 'name', 'rd']
+
+
+class VRFTenantSerializer(VRFSerializer):
+    """
+    Include tenant serializer. Useful for determining tenant inheritance for Prefixes and IPAddresses.
+    """
+
+    class Meta(VRFSerializer.Meta):
+        fields = ['id', 'name', 'rd', 'tenant']
+
+
 #
 # Roles
 #
 
-class RoleSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class RoleSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = Role
         fields = ['id', 'name', 'slug', 'weight']
 
 
-class NestedRoleSerializer(serializers.ModelSerializer):
+class RoleNestedSerializer(RoleSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:role-detail')
 
-    class Meta:
+    class Meta(RoleSerializer.Meta):
-        model = Role
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
 
 
 #
 # RIRs
 #
 
-class RIRSerializer(ModelValidationMixin, serializers.ModelSerializer):
+class RIRSerializer(serializers.ModelSerializer):
 
     class Meta:
         model = RIR
         fields = ['id', 'name', 'slug', 'is_private']
 
 
-class NestedRIRSerializer(serializers.ModelSerializer):
+class RIRNestedSerializer(RIRSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:rir-detail')
 
-    class Meta:
+    class Meta(RIRSerializer.Meta):
-        model = RIR
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
 
 
 #
 # Aggregates
 #
 
-class AggregateSerializer(CustomFieldModelSerializer):
+class AggregateSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    rir = NestedRIRSerializer()
+    rir = RIRNestedSerializer()
 
     class Meta:
         model = Aggregate
         fields = ['id', 'family', 'prefix', 'rir', 'date_added', 'description', 'custom_fields']
 
 
-class NestedAggregateSerializer(serializers.ModelSerializer):
+class AggregateNestedSerializer(AggregateSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:aggregate-detail')
 
     class Meta(AggregateSerializer.Meta):
-        model = Aggregate
+        fields = ['id', 'family', 'prefix']
-        fields = ['id', 'url', 'family', 'prefix']
-
-
-class WritableAggregateSerializer(CustomFieldModelSerializer):
-
-    class Meta:
-        model = Aggregate
-        fields = ['id', 'prefix', 'rir', 'date_added', 'description', 'custom_fields']
 
 
 #
@@ -111,182 +90,86 @@ class WritableAggregateSerializer(CustomFieldModelSerializer):
 #
 
 class VLANGroupSerializer(serializers.ModelSerializer):
-    site = NestedSiteSerializer()
+    site = SiteNestedSerializer()
 
     class Meta:
         model = VLANGroup
         fields = ['id', 'name', 'slug', 'site']
 
 
-class NestedVLANGroupSerializer(serializers.ModelSerializer):
+class VLANGroupNestedSerializer(VLANGroupSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:vlangroup-detail')
 
-    class Meta:
+    class Meta(VLANGroupSerializer.Meta):
-        model = VLANGroup
+        fields = ['id', 'name', 'slug']
-        fields = ['id', 'url', 'name', 'slug']
-
-
-class WritableVLANGroupSerializer(serializers.ModelSerializer):
-
-    class Meta:
-        model = VLANGroup
-        fields = ['id', 'name', 'slug', 'site']
-        validators = []
-
-    def validate(self, data):
-
-        # Validate uniqueness of name and slug if a site has been assigned.
-        if data.get('site', None):
-            for field in ['name', 'slug']:
-                validator = UniqueTogetherValidator(queryset=VLANGroup.objects.all(), fields=('site', field))
-                validator.set_context(self)
-                validator(data)
-
-        # Enforce model validation
-        super(WritableVLANGroupSerializer, self).validate(data)
-
-        return data
 
 
 #
 # VLANs
 #
 
-class VLANSerializer(CustomFieldModelSerializer):
+class VLANSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    site = NestedSiteSerializer()
+    site = SiteNestedSerializer()
-    group = NestedVLANGroupSerializer()
+    group = VLANGroupNestedSerializer()
-    tenant = NestedTenantSerializer()
+    tenant = TenantNestedSerializer()
-    status = ChoiceFieldSerializer(choices=VLAN_STATUS_CHOICES)
+    role = RoleNestedSerializer()
-    role = NestedRoleSerializer()
 
     class Meta:
         model = VLAN
-        fields = [
+        fields = ['id', 'site', 'group', 'vid', 'name', 'tenant', 'status', 'role', 'description', 'display_name',
-            'id', 'site', 'group', 'vid', 'name', 'tenant', 'status', 'role', 'description', 'display_name',
+                  'custom_fields']
-            'custom_fields',
-        ]
 
 
-class NestedVLANSerializer(serializers.ModelSerializer):
+class VLANNestedSerializer(VLANSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:vlan-detail')
 
-    class Meta:
+    class Meta(VLANSerializer.Meta):
-        model = VLAN
+        fields = ['id', 'vid', 'name', 'display_name']
-        fields = ['id', 'url', 'vid', 'name', 'display_name']
-
-
-class WritableVLANSerializer(CustomFieldModelSerializer):
-
-    class Meta:
-        model = VLAN
-        fields = ['id', 'site', 'group', 'vid', 'name', 'tenant', 'status', 'role', 'description', 'custom_fields']
-        validators = []
-
-    def validate(self, data):
-
-        # Validate uniqueness of vid and name if a group has been assigned.
-        if data.get('group', None):
-            for field in ['vid', 'name']:
-                validator = UniqueTogetherValidator(queryset=VLAN.objects.all(), fields=('group', field))
-                validator.set_context(self)
-                validator(data)
-
-        # Enforce model validation
-        super(WritableVLANSerializer, self).validate(data)
-
-        return data
 
 
 #
 # Prefixes
 #
 
-class PrefixSerializer(CustomFieldModelSerializer):
+class PrefixSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    site = NestedSiteSerializer()
+    site = SiteNestedSerializer()
-    vrf = NestedVRFSerializer()
+    vrf = VRFTenantSerializer()
-    tenant = NestedTenantSerializer()
+    tenant = TenantNestedSerializer()
-    vlan = NestedVLANSerializer()
+    vlan = VLANNestedSerializer()
-    status = ChoiceFieldSerializer(choices=PREFIX_STATUS_CHOICES)
+    role = RoleNestedSerializer()
-    role = NestedRoleSerializer()
 
     class Meta:
         model = Prefix
-        fields = [
+        fields = ['id', 'family', 'prefix', 'site', 'vrf', 'tenant', 'vlan', 'status', 'role', 'is_pool', 'description',
-            'id', 'family', 'prefix', 'site', 'vrf', 'tenant', 'vlan', 'status', 'role', 'is_pool', 'description',
+                  'custom_fields']
-            'custom_fields',
-        ]
 
 
-class NestedPrefixSerializer(serializers.ModelSerializer):
+class PrefixNestedSerializer(PrefixSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:prefix-detail')
 
-    class Meta:
+    class Meta(PrefixSerializer.Meta):
-        model = Prefix
+        fields = ['id', 'family', 'prefix']
-        fields = ['id', 'url', 'family', 'prefix']
-
-
-class WritablePrefixSerializer(CustomFieldModelSerializer):
-
-    class Meta:
-        model = Prefix
-        fields = [
-            'id', 'prefix', 'site', 'vrf', 'tenant', 'vlan', 'status', 'role', 'is_pool', 'description',
-            'custom_fields',
-        ]
 
 
 #
 # IP addresses
 #
 
-class IPAddressSerializer(CustomFieldModelSerializer):
+class IPAddressSerializer(CustomFieldSerializer, serializers.ModelSerializer):
-    vrf = NestedVRFSerializer()
+    vrf = VRFTenantSerializer()
-    tenant = NestedTenantSerializer()
+    tenant = TenantNestedSerializer()
-    status = ChoiceFieldSerializer(choices=IPADDRESS_STATUS_CHOICES)
+    interface = InterfaceNestedSerializer()
-    role = ChoiceFieldSerializer(choices=IPADDRESS_ROLE_CHOICES)
-    interface = InterfaceSerializer()
 
     class Meta:
         model = IPAddress
-        fields = [
+        fields = ['id', 'family', 'address', 'vrf', 'tenant', 'status', 'interface', 'description', 'nat_inside',
-            'id', 'family', 'address', 'vrf', 'tenant', 'status', 'role', 'interface', 'description', 'nat_inside',
+                  'nat_outside', 'custom_fields']
-            'nat_outside', 'custom_fields',
-        ]
 
 
-class NestedIPAddressSerializer(serializers.ModelSerializer):
+class IPAddressNestedSerializer(IPAddressSerializer):
-    url = serializers.HyperlinkedIdentityField(view_name='ipam-api:ipaddress-detail')
 
-    class Meta:
+    class Meta(IPAddressSerializer.Meta):
-        model = IPAddress
+        fields = ['id', 'family', 'address']
-        fields = ['id', 'url', 'family', 'address']
 
-IPAddressSerializer._declared_fields['nat_inside'] = NestedIPAddressSerializer()
+IPAddressSerializer._declared_fields['nat_inside'] = IPAddressNestedSerializer()
-IPAddressSerializer._declared_fields['nat_outside'] = NestedIPAddressSerializer()
+IPAddressSerializer._declared_fields['nat_outside'] = IPAddressNestedSerializer()
-
-
-class WritableIPAddressSerializer(CustomFieldModelSerializer):
-
-    class Meta:
-        model = IPAddress
-        fields = [
-            'id', 'address', 'vrf', 'tenant', 'status', 'role', 'interface', 'description', 'nat_inside',
-            'custom_fields',
-        ]
-
-
-class AvailableIPSerializer(serializers.Serializer):
-
-    def to_representation(self, instance):
-        if self.context.get('vrf'):
-            vrf = NestedVRFSerializer(self.context['vrf'], context={'request': self.context['request']}).data
-        else:
-            vrf = None
-        return OrderedDict([
-            ('family', self.context['prefix'].version),
-            ('address', '{}/{}'.format(instance, self.context['prefix'].prefixlen)),
-            ('vrf', vrf),
-        ])
 
 
 #
@@ -294,18 +177,15 @@ class AvailableIPSerializer(serializers.Serializer):
 #
 
 class ServiceSerializer(serializers.ModelSerializer):
-    device = NestedDeviceSerializer()
+    device = DeviceNestedSerializer()
-    protocol = ChoiceFieldSerializer(choices=IP_PROTOCOL_CHOICES)
+    ipaddresses = IPAddressNestedSerializer(many=True)
-    ipaddresses = NestedIPAddressSerializer(many=True)
 
     class Meta:
         model = Service
         fields = ['id', 'device', 'name', 'port', 'protocol', 'ipaddresses', 'description']
 
 
-# TODO: Figure out how to use ModelValidationMixin with ManyToManyFields. Calling clean() yields a ValueError.
+class ServiceNestedSerializer(ServiceSerializer):
-class WritableServiceSerializer(serializers.ModelSerializer):
 
-    class Meta:
+    class Meta(ServiceSerializer.Meta):
-        model = Service
+        fields = ['id', 'name', 'port', 'protocol']
-        fields = ['id', 'device', 'name', 'port', 'protocol', 'ipaddresses', 'description']

netbox/ipam/api/urls.py

@@ -1,43 +1,44 @@
-from __future__ import unicode_literals
+from django.conf.urls import url
 
-from rest_framework import routers
+from .views import *
-
-from . import views
 
 
-class IPAMRootView(routers.APIRootView):
+urlpatterns = [
-    """
-    IPAM API root view
-    """
-    def get_view_name(self):
-        return 'IPAM'
 
+    # VRFs
+    url(r'^vrfs/$', VRFListView.as_view(), name='vrf_list'),
+    url(r'^vrfs/(?P<pk>\d+)/$', VRFDetailView.as_view(), name='vrf_detail'),
 
-router = routers.DefaultRouter()
+    # Roles
-router.APIRootView = IPAMRootView
+    url(r'^roles/$', RoleListView.as_view(), name='role_list'),
+    url(r'^roles/(?P<pk>\d+)/$', RoleDetailView.as_view(), name='role_detail'),
 
-# VRFs
+    # RIRs
-router.register(r'vrfs', views.VRFViewSet)
+    url(r'^rirs/$', RIRListView.as_view(), name='rir_list'),
+    url(r'^rirs/(?P<pk>\d+)/$', RIRDetailView.as_view(), name='rir_detail'),
 
-# RIRs
+    # Aggregates
-router.register(r'rirs', views.RIRViewSet)
+    url(r'^aggregates/$', AggregateListView.as_view(), name='aggregate_list'),
+    url(r'^aggregates/(?P<pk>\d+)/$', AggregateDetailView.as_view(), name='aggregate_detail'),
 
-# Aggregates
+    # Prefixes
-router.register(r'aggregates', views.AggregateViewSet)
+    url(r'^prefixes/$', PrefixListView.as_view(), name='prefix_list'),
+    url(r'^prefixes/(?P<pk>\d+)/$', PrefixDetailView.as_view(), name='prefix_detail'),
 
-# Prefixes
+    # IP addresses
-router.register(r'roles', views.RoleViewSet)
+    url(r'^ip-addresses/$', IPAddressListView.as_view(), name='ipaddress_list'),
-router.register(r'prefixes', views.PrefixViewSet)
+    url(r'^ip-addresses/(?P<pk>\d+)/$', IPAddressDetailView.as_view(), name='ipaddress_detail'),
 
-# IP addresses
+    # VLAN groups
-router.register(r'ip-addresses', views.IPAddressViewSet)
+    url(r'^vlan-groups/$', VLANGroupListView.as_view(), name='vlangroup_list'),
+    url(r'^vlan-groups/(?P<pk>\d+)/$', VLANGroupDetailView.as_view(), name='vlangroup_detail'),
 
-# VLANs
+    # VLANs
-router.register(r'vlan-groups', views.VLANGroupViewSet)
+    url(r'^vlans/$', VLANListView.as_view(), name='vlan_list'),
-router.register(r'vlans', views.VLANViewSet)
+    url(r'^vlans/(?P<pk>\d+)/$', VLANDetailView.as_view(), name='vlan_detail'),
 
-# Services
+    # Services
-router.register(r'services', views.ServiceViewSet)
+    url(r'^services/$', ServiceListView.as_view(), name='service_list'),
+    url(r'^services/(?P<pk>\d+)/$', ServiceDetailView.as_view(), name='service_detail'),
 
-app_name = 'ipam-api'
+]
-urlpatterns = router.urls

netbox/ipam/api/views.py

@@ -1,18 +1,9 @@
-from __future__ import unicode_literals
+from rest_framework import generics
-
-from rest_framework import status
-from rest_framework.decorators import detail_route
-from rest_framework.exceptions import PermissionDenied
-from rest_framework.response import Response
-from rest_framework.viewsets import ModelViewSet
-
-from django.conf import settings
-from django.shortcuts import get_object_or_404
 
 from ipam.models import Aggregate, IPAddress, Prefix, RIR, Role, Service, VLAN, VLANGroup, VRF
 from ipam import filters
-from extras.api.views import CustomFieldModelViewSet
+
-from utilities.api import WritableSerializerMixin
+from extras.api.views import CustomFieldModelAPIView
 from . import serializers
 
 
@@ -20,150 +11,190 @@ from . import serializers
 # VRFs
 #
 
-class VRFViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class VRFListView(CustomFieldModelAPIView, generics.ListAPIView):
-    queryset = VRF.objects.select_related('tenant')
+    """
+    List all VRFs
+    """
+    queryset = VRF.objects.select_related('tenant').prefetch_related('custom_field_values__field')
     serializer_class = serializers.VRFSerializer
-    write_serializer_class = serializers.WritableVRFSerializer
     filter_class = filters.VRFFilter
 
 
-#
+class VRFDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
-# RIRs
+    """
-#
+    Retrieve a single VRF
-
+    """
-class RIRViewSet(ModelViewSet):
+    queryset = VRF.objects.select_related('tenant').prefetch_related('custom_field_values__field')
-    queryset = RIR.objects.all()
+    serializer_class = serializers.VRFSerializer
-    serializer_class = serializers.RIRSerializer
-    filter_class = filters.RIRFilter
-
-
-#
-# Aggregates
-#
-
-class AggregateViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
-    queryset = Aggregate.objects.select_related('rir')
-    serializer_class = serializers.AggregateSerializer
-    write_serializer_class = serializers.WritableAggregateSerializer
-    filter_class = filters.AggregateFilter
 
 
 #
 # Roles
 #
 
-class RoleViewSet(ModelViewSet):
+class RoleListView(generics.ListAPIView):
+    """
+    List all roles
+    """
     queryset = Role.objects.all()
     serializer_class = serializers.RoleSerializer
-    filter_class = filters.RoleFilter
+
+
+class RoleDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single role
+    """
+    queryset = Role.objects.all()
+    serializer_class = serializers.RoleSerializer
+
+
+#
+# RIRs
+#
+
+class RIRListView(generics.ListAPIView):
+    """
+    List all RIRs
+    """
+    queryset = RIR.objects.all()
+    serializer_class = serializers.RIRSerializer
+
+
+class RIRDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single RIR
+    """
+    queryset = RIR.objects.all()
+    serializer_class = serializers.RIRSerializer
+
+
+#
+# Aggregates
+#
+
+class AggregateListView(CustomFieldModelAPIView, generics.ListAPIView):
+    """
+    List aggregates (filterable)
+    """
+    queryset = Aggregate.objects.select_related('rir').prefetch_related('custom_field_values__field')
+    serializer_class = serializers.AggregateSerializer
+    filter_class = filters.AggregateFilter
+
+
+class AggregateDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
+    """
+    Retrieve a single aggregate
+    """
+    queryset = Aggregate.objects.select_related('rir').prefetch_related('custom_field_values__field')
+    serializer_class = serializers.AggregateSerializer
 
 
 #
 # Prefixes
 #
 
-class PrefixViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class PrefixListView(CustomFieldModelAPIView, generics.ListAPIView):
-    queryset = Prefix.objects.select_related('site', 'vrf__tenant', 'tenant', 'vlan', 'role')
+    """
+    List prefixes (filterable)
+    """
+    queryset = Prefix.objects.select_related('site', 'vrf__tenant', 'tenant', 'vlan', 'role')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.PrefixSerializer
-    write_serializer_class = serializers.WritablePrefixSerializer
     filter_class = filters.PrefixFilter
 
-    @detail_route(url_path='available-ips', methods=['get', 'post'])
+
-    def available_ips(self, request, pk=None):
+class PrefixDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
     """
-        A convenience method for returning available IP addresses within a prefix. By default, the number of IPs
+    Retrieve a single prefix
-        returned will be equivalent to PAGINATE_COUNT. An arbitrary limit (up to MAX_PAGE_SIZE, if set) may be passed,
-        however results will not be paginated.
     """
-        prefix = get_object_or_404(Prefix, pk=pk)
+    queryset = Prefix.objects.select_related('site', 'vrf__tenant', 'tenant', 'vlan', 'role')\
-
+        .prefetch_related('custom_field_values__field')
-        # Create the next available IP within the prefix
+    serializer_class = serializers.PrefixSerializer
-        if request.method == 'POST':
-
-            # Permissions check
-            if not request.user.has_perm('ipam.add_ipaddress'):
-                raise PermissionDenied()
-
-            # Find the first available IP address in the prefix
-            try:
-                ipaddress = list(prefix.get_available_ips())[0]
-            except IndexError:
-                return Response(
-                    {
-                        "detail": "There are no available IPs within this prefix ({})".format(prefix)
-                    },
-                    status=status.HTTP_400_BAD_REQUEST
-                )
-
-            # Create the new IP address
-            data = request.data.copy()
-            data['address'] = '{}/{}'.format(ipaddress, prefix.prefix.prefixlen)
-            data['vrf'] = prefix.vrf
-            serializer = serializers.WritableIPAddressSerializer(data=data)
-            if serializer.is_valid():
-                serializer.save()
-                return Response(serializer.data, status=status.HTTP_201_CREATED)
-            return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
-
-        # Determine the maximum amount of IPs to return
-        else:
-            try:
-                limit = int(request.query_params.get('limit', settings.PAGINATE_COUNT))
-            except ValueError:
-                limit = settings.PAGINATE_COUNT
-            if settings.MAX_PAGE_SIZE:
-                limit = min(limit, settings.MAX_PAGE_SIZE)
-
-            # Calculate available IPs within the prefix
-            ip_list = list(prefix.get_available_ips())[:limit]
-            serializer = serializers.AvailableIPSerializer(ip_list, many=True, context={
-                'request': request,
-                'prefix': prefix.prefix,
-                'vrf': prefix.vrf,
-            })
-
-            return Response(serializer.data)
 
 
 #
 # IP addresses
 #
 
-class IPAddressViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class IPAddressListView(CustomFieldModelAPIView, generics.ListAPIView):
-    queryset = IPAddress.objects.select_related('vrf__tenant', 'tenant', 'interface__device', 'nat_inside')
+    """
+    List IP addresses (filterable)
+    """
+    queryset = IPAddress.objects.select_related('vrf__tenant', 'tenant', 'interface__device', 'nat_inside')\
+        .prefetch_related('nat_outside', 'custom_field_values__field')
     serializer_class = serializers.IPAddressSerializer
-    write_serializer_class = serializers.WritableIPAddressSerializer
     filter_class = filters.IPAddressFilter
 
 
+class IPAddressDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
+    """
+    Retrieve a single IP address
+    """
+    queryset = IPAddress.objects.select_related('vrf__tenant', 'tenant', 'interface__device', 'nat_inside')\
+        .prefetch_related('nat_outside', 'custom_field_values__field')
+    serializer_class = serializers.IPAddressSerializer
+
+
 #
 # VLAN groups
 #
 
-class VLANGroupViewSet(WritableSerializerMixin, ModelViewSet):
+class VLANGroupListView(generics.ListAPIView):
+    """
+    List all VLAN groups
+    """
     queryset = VLANGroup.objects.select_related('site')
     serializer_class = serializers.VLANGroupSerializer
-    write_serializer_class = serializers.WritableVLANGroupSerializer
     filter_class = filters.VLANGroupFilter
 
 
+class VLANGroupDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single VLAN group
+    """
+    queryset = VLANGroup.objects.select_related('site')
+    serializer_class = serializers.VLANGroupSerializer
+
+
 #
 # VLANs
 #
 
-class VLANViewSet(WritableSerializerMixin, CustomFieldModelViewSet):
+class VLANListView(CustomFieldModelAPIView, generics.ListAPIView):
-    queryset = VLAN.objects.select_related('site', 'group', 'tenant', 'role')
+    """
+    List VLANs (filterable)
+    """
+    queryset = VLAN.objects.select_related('site', 'group', 'tenant', 'role')\
+        .prefetch_related('custom_field_values__field')
     serializer_class = serializers.VLANSerializer
-    write_serializer_class = serializers.WritableVLANSerializer
     filter_class = filters.VLANFilter
 
 
+class VLANDetailView(CustomFieldModelAPIView, generics.RetrieveAPIView):
+    """
+    Retrieve a single VLAN
+    """
+    queryset = VLAN.objects.select_related('site', 'group', 'tenant', 'role')\
+        .prefetch_related('custom_field_values__field')
+    serializer_class = serializers.VLANSerializer
+
+
 #
 # Services
 #
 
-class ServiceViewSet(WritableSerializerMixin, ModelViewSet):
+class ServiceListView(generics.ListAPIView):
-    queryset = Service.objects.select_related('device')
+    """
+    List services (filterable)
+    """
+    queryset = Service.objects.select_related('device').prefetch_related('ipaddresses')
     serializer_class = serializers.ServiceSerializer
-    write_serializer_class = serializers.WritableServiceSerializer
     filter_class = filters.ServiceFilter
+
+
+class ServiceDetailView(generics.RetrieveAPIView):
+    """
+    Retrieve a single service
+    """
+    queryset = Service.objects.select_related('device').prefetch_related('ipaddresses')
+    serializer_class = serializers.ServiceSerializer

netbox/ipam/apps.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from django.apps import AppConfig
 
 

netbox/ipam/constants.py

@@ -1,78 +0,0 @@
-from __future__ import unicode_literals
-
-
-# IP address families
-AF_CHOICES = (
-    (4, 'IPv4'),
-    (6, 'IPv6'),
-)
-
-# Prefix statuses
-PREFIX_STATUS_CONTAINER = 0
-PREFIX_STATUS_ACTIVE = 1
-PREFIX_STATUS_RESERVED = 2
-PREFIX_STATUS_DEPRECATED = 3
-PREFIX_STATUS_CHOICES = (
-    (PREFIX_STATUS_CONTAINER, 'Container'),
-    (PREFIX_STATUS_ACTIVE, 'Active'),
-    (PREFIX_STATUS_RESERVED, 'Reserved'),
-    (PREFIX_STATUS_DEPRECATED, 'Deprecated')
-)
-
-# IP address statuses
-IPADDRESS_STATUS_ACTIVE = 1
-IPADDRESS_STATUS_RESERVED = 2
-IPADDRESS_STATUS_DEPRECATED = 3
-IPADDRESS_STATUS_DHCP = 5
-IPADDRESS_STATUS_CHOICES = (
-    (IPADDRESS_STATUS_ACTIVE, 'Active'),
-    (IPADDRESS_STATUS_RESERVED, 'Reserved'),
-    (IPADDRESS_STATUS_DEPRECATED, 'Deprecated'),
-    (IPADDRESS_STATUS_DHCP, 'DHCP')
-)
-
-# IP address roles
-IPADDRESS_ROLE_LOOPBACK = 10
-IPADDRESS_ROLE_SECONDARY = 20
-IPADDRESS_ROLE_ANYCAST = 30
-IPADDRESS_ROLE_VIP = 40
-IPADDRESS_ROLE_VRRP = 41
-IPADDRESS_ROLE_HSRP = 42
-IPADDRESS_ROLE_GLBP = 43
-IPADDRESS_ROLE_CHOICES = (
-    (IPADDRESS_ROLE_LOOPBACK, 'Loopback'),
-    (IPADDRESS_ROLE_SECONDARY, 'Secondary'),
-    (IPADDRESS_ROLE_ANYCAST, 'Anycast'),
-    (IPADDRESS_ROLE_VIP, 'VIP'),
-    (IPADDRESS_ROLE_VRRP, 'VRRP'),
-    (IPADDRESS_ROLE_HSRP, 'HSRP'),
-    (IPADDRESS_ROLE_GLBP, 'GLBP'),
-)
-
-# VLAN statuses
-VLAN_STATUS_ACTIVE = 1
-VLAN_STATUS_RESERVED = 2
-VLAN_STATUS_DEPRECATED = 3
-VLAN_STATUS_CHOICES = (
-    (VLAN_STATUS_ACTIVE, 'Active'),
-    (VLAN_STATUS_RESERVED, 'Reserved'),
-    (VLAN_STATUS_DEPRECATED, 'Deprecated')
-)
-
-# Bootstrap CSS classes for various statuses
-STATUS_CHOICE_CLASSES = {
-    0: 'default',
-    1: 'primary',
-    2: 'info',
-    3: 'danger',
-    4: 'warning',
-    5: 'success',
-}
-
-# IP protocols (for services)
-IP_PROTOCOL_TCP = 6
-IP_PROTOCOL_UDP = 17
-IP_PROTOCOL_CHOICES = (
-    (IP_PROTOCOL_TCP, 'TCP'),
-    (IP_PROTOCOL_UDP, 'UDP'),
-)

netbox/ipam/fields.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from netaddr import IPNetwork
 
 from django.core.exceptions import ValidationError

netbox/ipam/filters.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 import django_filters
 from netaddr import IPNetwork
 from netaddr.core import AddrFormatError
@@ -10,10 +8,8 @@ from dcim.models import Site, Device, Interface
 from extras.filters import CustomFieldFilterSet
 from tenancy.models import Tenant
 from utilities.filters import NullableModelMultipleChoiceFilter, NumericInFilter
-from .models import (
+
-    Aggregate, IPAddress, IPADDRESS_ROLE_CHOICES, IPADDRESS_STATUS_CHOICES, Prefix, PREFIX_STATUS_CHOICES, RIR, Role,
+from .models import Aggregate, IPAddress, Prefix, RIR, Role, Service, VLAN, VLANGroup, VRF
-    Service, VLAN, VLAN_STATUS_CHOICES, VLANGroup, VRF,
-)
 
 
 class VRFFilter(CustomFieldFilterSet, django_filters.FilterSet):
@@ -23,6 +19,7 @@ class VRFFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Search',
     )
     tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         label='Tenant (ID)',
     )
@@ -44,7 +41,7 @@ class VRFFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
     class Meta:
         model = VRF
-        fields = ['name', 'rd', 'enforce_unique']
+        fields = ['name', 'rd']
 
 
 class RIRFilter(django_filters.FilterSet):
@@ -52,7 +49,7 @@ class RIRFilter(django_filters.FilterSet):
 
     class Meta:
         model = RIR
-        fields = ['name', 'slug', 'is_private']
+        fields = ['is_private']
 
 
 class AggregateFilter(CustomFieldFilterSet, django_filters.FilterSet):
@@ -62,6 +59,7 @@ class AggregateFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Search',
     )
     rir_id = django_filters.ModelMultipleChoiceFilter(
+        name='rir',
         queryset=RIR.objects.all(),
         label='RIR (ID)',
     )
@@ -83,18 +81,11 @@ class AggregateFilter(CustomFieldFilterSet, django_filters.FilterSet):
         try:
             prefix = str(IPNetwork(value.strip()).cidr)
             qs_filter |= Q(prefix__net_contains_or_equals=prefix)
-        except (AddrFormatError, ValueError):
+        except AddrFormatError:
             pass
         return queryset.filter(qs_filter)
 
 
-class RoleFilter(django_filters.FilterSet):
-
-    class Meta:
-        model = Role
-        fields = ['name', 'slug']
-
-
 class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
     id__in = NumericInFilter(name='id', lookup_expr='in')
     q = django_filters.CharFilter(
@@ -110,6 +101,7 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Mask length',
     )
     vrf_id = NullableModelMultipleChoiceFilter(
+        name='vrf_id',
         queryset=VRF.objects.all(),
         label='VRF',
     )
@@ -120,6 +112,7 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='VRF (RD)',
     )
     tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         label='Tenant (ID)',
     )
@@ -130,6 +123,7 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Tenant (slug)',
     )
     site_id = NullableModelMultipleChoiceFilter(
+        name='site',
         queryset=Site.objects.all(),
         label='Site (ID)',
     )
@@ -140,6 +134,7 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Site (slug)',
     )
     vlan_id = NullableModelMultipleChoiceFilter(
+        name='vlan',
         queryset=VLAN.objects.all(),
         label='VLAN (ID)',
     )
@@ -148,6 +143,7 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='VLAN number (1-4095)',
     )
     role_id = NullableModelMultipleChoiceFilter(
+        name='role',
         queryset=Role.objects.all(),
         label='Role (ID)',
     )
@@ -157,13 +153,10 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         to_field_name='slug',
         label='Role (slug)',
     )
-    status = django_filters.MultipleChoiceFilter(
-        choices=PREFIX_STATUS_CHOICES
-    )
 
     class Meta:
         model = Prefix
-        fields = ['family', 'is_pool']
+        fields = ['family', 'status']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -172,7 +165,7 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         try:
             prefix = str(IPNetwork(value.strip()).cidr)
             qs_filter |= Q(prefix__net_contains_or_equals=prefix)
-        except (AddrFormatError, ValueError):
+        except AddrFormatError:
             pass
         return queryset.filter(qs_filter)
 
@@ -183,7 +176,7 @@ class PrefixFilter(CustomFieldFilterSet, django_filters.FilterSet):
         try:
             query = str(IPNetwork(value).cidr)
             return queryset.filter(prefix__net_contained_or_equal=query)
-        except (AddrFormatError, ValueError):
+        except AddrFormatError:
             return queryset.none()
 
     def filter_mask_length(self, queryset, name, value):
@@ -207,6 +200,7 @@ class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Mask length',
     )
     vrf_id = NullableModelMultipleChoiceFilter(
+        name='vrf_id',
         queryset=VRF.objects.all(),
         label='VRF',
     )
@@ -217,6 +211,7 @@ class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='VRF (RD)',
     )
     tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         label='Tenant (ID)',
     )
@@ -238,19 +233,14 @@ class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Device (name)',
     )
     interface_id = django_filters.ModelMultipleChoiceFilter(
+        name='interface',
         queryset=Interface.objects.all(),
         label='Interface (ID)',
     )
-    status = django_filters.MultipleChoiceFilter(
-        choices=IPADDRESS_STATUS_CHOICES
-    )
-    role = django_filters.MultipleChoiceFilter(
-        choices=IPADDRESS_ROLE_CHOICES
-    )
 
     class Meta:
         model = IPAddress
-        fields = ['family']
+        fields = ['family', 'status']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -259,7 +249,7 @@ class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
         try:
             ipaddress = str(IPNetwork(value.strip()))
             qs_filter |= Q(address__net_host=ipaddress)
-        except (AddrFormatError, ValueError):
+        except AddrFormatError:
             pass
         return queryset.filter(qs_filter)
 
@@ -270,7 +260,7 @@ class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
         try:
             query = str(IPNetwork(value.strip()).cidr)
             return queryset.filter(address__net_host_contained=query)
-        except (AddrFormatError, ValueError):
+        except AddrFormatError:
             return queryset.none()
 
     def filter_mask_length(self, queryset, name, value):
@@ -281,6 +271,7 @@ class IPAddressFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
 class VLANGroupFilter(django_filters.FilterSet):
     site_id = NullableModelMultipleChoiceFilter(
+        name='site',
         queryset=Site.objects.all(),
         label='Site (ID)',
     )
@@ -293,7 +284,7 @@ class VLANGroupFilter(django_filters.FilterSet):
 
     class Meta:
         model = VLANGroup
-        fields = ['name', 'slug']
+        fields = ['name']
 
 
 class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
@@ -303,6 +294,7 @@ class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Search',
     )
     site_id = NullableModelMultipleChoiceFilter(
+        name='site',
         queryset=Site.objects.all(),
         label='Site (ID)',
     )
@@ -313,6 +305,7 @@ class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Site (slug)',
     )
     group_id = NullableModelMultipleChoiceFilter(
+        name='group',
         queryset=VLANGroup.objects.all(),
         label='Group (ID)',
     )
@@ -323,6 +316,7 @@ class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Group',
     )
     tenant_id = NullableModelMultipleChoiceFilter(
+        name='tenant',
         queryset=Tenant.objects.all(),
         label='Tenant (ID)',
     )
@@ -333,6 +327,7 @@ class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
         label='Tenant (slug)',
     )
     role_id = NullableModelMultipleChoiceFilter(
+        name='role',
         queryset=Role.objects.all(),
         label='Role (ID)',
     )
@@ -342,13 +337,10 @@ class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
         to_field_name='slug',
         label='Role (slug)',
     )
-    status = django_filters.MultipleChoiceFilter(
-        choices=VLAN_STATUS_CHOICES
-    )
 
     class Meta:
         model = VLAN
-        fields = ['vid', 'name']
+        fields = ['name', 'vid', 'status']
 
     def search(self, queryset, name, value):
         if not value.strip():
@@ -363,6 +355,7 @@ class VLANFilter(CustomFieldFilterSet, django_filters.FilterSet):
 
 class ServiceFilter(django_filters.FilterSet):
     device_id = django_filters.ModelMultipleChoiceFilter(
+        name='device',
         queryset=Device.objects.all(),
         label='Device (ID)',
     )

netbox/ipam/formfields.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from netaddr import IPNetwork, AddrFormatError
 
 from django import forms

netbox/ipam/forms.py

@@ -1,21 +1,17 @@
-from __future__ import unicode_literals
-
 from django import forms
-from django.core.exceptions import MultipleObjectsReturned
 from django.db.models import Count
 
 from dcim.models import Site, Rack, Device, Interface
 from extras.forms import CustomFieldForm, CustomFieldBulkEditForm, CustomFieldFilterForm
-from tenancy.forms import TenancyForm
 from tenancy.models import Tenant
 from utilities.forms import (
-    APISelect, BootstrapMixin, BulkEditNullBooleanSelect, ChainedModelChoiceField, CSVChoiceField,
+    APISelect, BootstrapMixin, BulkImportForm, CSVDataField, ExpandableIPAddressField, FilterChoiceField, Livesearch,
-    ExpandableIPAddressField, FilterChoiceField, FlexibleModelChoiceField, Livesearch, ReturnURLForm, SlugField,
+    SlugField, add_blank_choice,
-    add_blank_choice,
 )
+
 from .models import (
-    Aggregate, IPAddress, IPADDRESS_ROLE_CHOICES, IPADDRESS_STATUS_CHOICES, Prefix, PREFIX_STATUS_CHOICES, RIR, Role,
+    Aggregate, IPAddress, IPADDRESS_STATUS_CHOICES, Prefix, PREFIX_STATUS_CHOICES, RIR, Role, Service, VLAN,
-    Service, VLAN, VLANGroup, VLAN_STATUS_CHOICES, VRF,
+    VLANGroup, VLAN_STATUS_CHOICES, VRF,
 )
 
 
@@ -36,11 +32,11 @@ IPADDRESS_MASK_LENGTH_CHOICES = PREFIX_MASK_LENGTH_CHOICES + [(128, 128)]
 # VRFs
 #
 
-class VRFForm(BootstrapMixin, TenancyForm, CustomFieldForm):
+class VRFForm(BootstrapMixin, CustomFieldForm):
 
     class Meta:
         model = VRF
-        fields = ['name', 'rd', 'enforce_unique', 'description', 'tenant_group', 'tenant']
+        fields = ['name', 'rd', 'tenant', 'enforce_unique', 'description']
         labels = {
             'rd': "RD",
         }
@@ -49,31 +45,22 @@ class VRFForm(BootstrapMixin, TenancyForm, CustomFieldForm):
         }
 
 
-class VRFCSVForm(forms.ModelForm):
+class VRFFromCSVForm(forms.ModelForm):
-    tenant = forms.ModelChoiceField(
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
-        queryset=Tenant.objects.all(),
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
-        required=False,
-        to_field_name='name',
-        help_text='Name of assigned tenant',
-        error_messages={
-            'invalid_choice': 'Tenant not found.',
-        }
-    )
 
     class Meta:
         model = VRF
         fields = ['name', 'rd', 'tenant', 'enforce_unique', 'description']
-        help_texts = {
+
-            'name': 'VRF name',
+
-        }
+class VRFImportForm(BootstrapMixin, BulkImportForm):
+    csv = CSVDataField(csv_form=VRFFromCSVForm)
 
 
 class VRFBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=VRF.objects.all(), widget=forms.MultipleHiddenInput)
     tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
-    enforce_unique = forms.NullBooleanField(
-        required=False, widget=BulkEditNullBooleanSelect, label='Enforce unique space'
-    )
     description = forms.CharField(max_length=100, required=False)
 
     class Meta:
@@ -123,21 +110,19 @@ class AggregateForm(BootstrapMixin, CustomFieldForm):
         }
 
 
-class AggregateCSVForm(forms.ModelForm):
+class AggregateFromCSVForm(forms.ModelForm):
-    rir = forms.ModelChoiceField(
+    rir = forms.ModelChoiceField(queryset=RIR.objects.all(), to_field_name='name',
-        queryset=RIR.objects.all(),
+                                 error_messages={'invalid_choice': 'RIR not found.'})
-        to_field_name='name',
-        help_text='Name of parent RIR',
-        error_messages={
-            'invalid_choice': 'RIR not found.',
-        }
-    )
 
     class Meta:
         model = Aggregate
         fields = ['prefix', 'rir', 'date_added', 'description']
 
 
+class AggregateImportForm(BootstrapMixin, BulkImportForm):
+    csv = CSVDataField(csv_form=AggregateFromCSVForm)
+
+
 class AggregateBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     pk = forms.ModelMultipleChoiceField(queryset=Aggregate.objects.all(), widget=forms.MultipleHiddenInput)
     rir = forms.ModelChoiceField(queryset=RIR.objects.all(), required=False, label='RIR')
@@ -175,147 +160,89 @@ class RoleForm(BootstrapMixin, forms.ModelForm):
 # Prefixes
 #
 
-class PrefixForm(BootstrapMixin, TenancyForm, CustomFieldForm):
+class PrefixForm(BootstrapMixin, CustomFieldForm):
-    site = forms.ModelChoiceField(
+    site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False, label='Site',
-        queryset=Site.objects.all(),
+                                  widget=forms.Select(attrs={'filter-for': 'vlan', 'nullable': 'true'}))
-        required=False,
+    vlan = forms.ModelChoiceField(queryset=VLAN.objects.all(), required=False, label='VLAN',
-        label='Site',
+                                  widget=APISelect(api_url='/api/ipam/vlans/?site_id={{site}}',
-        widget=forms.Select(
+                                                   display_field='display_name'))
-            attrs={'filter-for': 'vlan_group', 'nullable': 'true'}
-        )
-    )
-    vlan_group = ChainedModelChoiceField(
-        queryset=VLANGroup.objects.all(),
-        chains=(
-            ('site', 'site'),
-        ),
-        required=False,
-        label='VLAN group',
-        widget=APISelect(
-            api_url='/api/ipam/vlan-groups/?site_id={{site}}',
-            attrs={'filter-for': 'vlan', 'nullable': 'true'}
-        )
-    )
-    vlan = ChainedModelChoiceField(
-        queryset=VLAN.objects.all(),
-        chains=(
-            ('site', 'site'),
-            ('group', 'vlan_group'),
-        ),
-        required=False,
-        label='VLAN',
-        widget=APISelect(
-            api_url='/api/ipam/vlans/?site_id={{site}}&group_id={{vlan_group}}', display_field='display_name'
-        )
-    )
 
     class Meta:
         model = Prefix
-        fields = ['prefix', 'vrf', 'site', 'vlan', 'status', 'role', 'is_pool', 'description', 'tenant_group', 'tenant']
+        fields = ['prefix', 'vrf', 'tenant', 'site', 'vlan', 'status', 'role', 'is_pool', 'description']
 
     def __init__(self, *args, **kwargs):
-
-        # Initialize helper selectors
-        instance = kwargs.get('instance')
-        initial = kwargs.get('initial', {})
-        if instance and instance.vlan is not None:
-            initial['vlan_group'] = instance.vlan.group
-        kwargs['initial'] = initial
-
         super(PrefixForm, self).__init__(*args, **kwargs)
 
         self.fields['vrf'].empty_label = 'Global'
 
+        # Initialize field without choices to avoid pulling all VLANs from the database
+        if self.is_bound and self.data.get('site'):
+            self.fields['vlan'].queryset = VLAN.objects.filter(site__pk=self.data['site'])
+        elif self.initial.get('site'):
+            self.fields['vlan'].queryset = VLAN.objects.filter(site=self.initial['site'])
+        else:
+            self.fields['vlan'].queryset = VLAN.objects.filter(site=None)
 
-class PrefixCSVForm(forms.ModelForm):
+
-    vrf = forms.ModelChoiceField(
+class PrefixFromCSVForm(forms.ModelForm):
-        queryset=VRF.objects.all(),
+    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, to_field_name='rd',
-        required=False,
+                                 error_messages={'invalid_choice': 'VRF not found.'})
-        to_field_name='rd',
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
-        help_text='Route distinguisher of parent VRF',
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
-        error_messages={
+    site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False, to_field_name='name',
-            'invalid_choice': 'VRF not found.',
+                                  error_messages={'invalid_choice': 'Site not found.'})
-        }
+    vlan_group_name = forms.CharField(required=False)
-    )
+    vlan_vid = forms.IntegerField(required=False)
-    tenant = forms.ModelChoiceField(
+    status_name = forms.ChoiceField(choices=[(s[1], s[0]) for s in PREFIX_STATUS_CHOICES])
-        queryset=Tenant.objects.all(),
+    role = forms.ModelChoiceField(queryset=Role.objects.all(), required=False, to_field_name='name',
-        required=False,
+                                  error_messages={'invalid_choice': 'Invalid role.'})
-        to_field_name='name',
-        help_text='Name of assigned tenant',
-        error_messages={
-            'invalid_choice': 'Tenant not found.',
-        }
-    )
-    site = forms.ModelChoiceField(
-        queryset=Site.objects.all(),
-        required=False,
-        to_field_name='name',
-        help_text='Name of parent site',
-        error_messages={
-            'invalid_choice': 'Site not found.',
-        }
-    )
-    vlan_group = forms.CharField(
-        help_text='Group name of assigned VLAN',
-        required=False
-    )
-    vlan_vid = forms.IntegerField(
-        help_text='Numeric ID of assigned VLAN',
-        required=False
-    )
-    status = CSVChoiceField(
-        choices=IPADDRESS_STATUS_CHOICES,
-        help_text='Operational status'
-    )
-    role = forms.ModelChoiceField(
-        queryset=Role.objects.all(),
-        required=False,
-        to_field_name='name',
-        help_text='Functional role',
-        error_messages={
-            'invalid_choice': 'Invalid role.',
-        }
-    )
 
     class Meta:
         model = Prefix
-        fields = [
+        fields = ['prefix', 'vrf', 'tenant', 'site', 'vlan_group_name', 'vlan_vid', 'status_name', 'role', 'is_pool',
-            'prefix', 'vrf', 'tenant', 'site', 'vlan_group', 'vlan_vid', 'status', 'role', 'is_pool', 'description',
+                  'description']
-        ]
 
     def clean(self):
 
-        super(PrefixCSVForm, self).clean()
+        super(PrefixFromCSVForm, self).clean()
 
         site = self.cleaned_data.get('site')
-        vlan_group = self.cleaned_data.get('vlan_group')
+        vlan_group_name = self.cleaned_data.get('vlan_group_name')
         vlan_vid = self.cleaned_data.get('vlan_vid')
 
         # Validate VLAN
-        if vlan_group and vlan_vid:
+        vlan_group = None
+        if vlan_group_name:
             try:
-                self.instance.vlan = VLAN.objects.get(site=site, group__name=vlan_group, vid=vlan_vid)
+                vlan_group = VLANGroup.objects.get(site=site, name=vlan_group_name)
+            except VLANGroup.DoesNotExist:
+                self.add_error('vlan_group_name', "Invalid VLAN group ({} - {}).".format(site, vlan_group_name))
+        if vlan_vid and vlan_group:
+            try:
+                self.instance.vlan = VLAN.objects.get(group=vlan_group, vid=vlan_vid)
             except VLAN.DoesNotExist:
-                if site:
+                self.add_error('vlan_vid', "Invalid VLAN ID ({} - {}).".format(vlan_group, vlan_vid))
-                    raise forms.ValidationError("VLAN {} not found in site {} group {}".format(
+        elif vlan_vid and site:
-                        vlan_vid, site, vlan_group
+            try:
-                    ))
+                self.instance.vlan = VLAN.objects.get(site=site, vid=vlan_vid)
-                else:
+            except VLAN.DoesNotExist:
-                    raise forms.ValidationError("Global VLAN {} not found in group {}".format(vlan_vid, vlan_group))
+                self.add_error('vlan_vid', "Invalid VLAN ID ({}) for site {}.".format(vlan_vid, site))
-            except MultipleObjectsReturned:
+            except VLAN.MultipleObjectsReturned:
-                raise forms.ValidationError(
+                self.add_error('vlan_vid', "Multiple VLANs found ({} - VID {})".format(site, vlan_vid))
-                    "Multiple VLANs with VID {} found in group {}".format(vlan_vid, vlan_group)
-                )
         elif vlan_vid:
-            try:
+            self.add_error('vlan_vid', "Must specify site and/or VLAN group when assigning a VLAN.")
-                self.instance.vlan = VLAN.objects.get(site=site, group__isnull=True, vid=vlan_vid)
+
-            except VLAN.DoesNotExist:
+    def save(self, *args, **kwargs):
-                if site:
+
-                    raise forms.ValidationError("VLAN {} not found in site {}".format(vlan_vid, site))
+        # Assign Prefix status by name
-                else:
+        self.instance.status = dict(self.fields['status_name'].choices)[self.cleaned_data['status_name']]
-                    raise forms.ValidationError("Global VLAN {} not found".format(vlan_vid))
+
-            except MultipleObjectsReturned:
+        return super(PrefixFromCSVForm, self).save(*args, **kwargs)
-                raise forms.ValidationError("Multiple VLANs with VID {} found".format(vlan_vid))
+
+
+class PrefixImportForm(BootstrapMixin, BulkImportForm):
+    csv = CSVDataField(csv_form=PrefixFromCSVForm)
 
 
 class PrefixBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
@@ -325,7 +252,6 @@ class PrefixBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
     status = forms.ChoiceField(choices=add_blank_choice(PREFIX_STATUS_CHOICES), required=False)
     role = forms.ModelChoiceField(queryset=Role.objects.all(), required=False)
-    is_pool = forms.NullBooleanField(required=False, widget=BulkEditNullBooleanSelect, label='Is a pool')
     description = forms.CharField(max_length=100, required=False)
 
     class Meta:
@@ -336,7 +262,7 @@ def prefix_status_choices():
     status_counts = {}
     for status in Prefix.objects.values('status').annotate(count=Count('status')).order_by('status'):
         status_counts[status['status']] = status['count']
-    return [(s[0], '{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in PREFIX_STATUS_CHOICES]
+    return [(s[0], u'{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in PREFIX_STATUS_CHOICES]
 
 
 class PrefixFilterForm(BootstrapMixin, CustomFieldFilterForm):
@@ -376,253 +302,150 @@ class PrefixFilterForm(BootstrapMixin, CustomFieldFilterForm):
 # IP addresses
 #
 
-class IPAddressForm(BootstrapMixin, TenancyForm, ReturnURLForm, CustomFieldForm):
+class IPAddressForm(BootstrapMixin, CustomFieldForm):
-    interface_site = forms.ModelChoiceField(
+    nat_site = forms.ModelChoiceField(queryset=Site.objects.all(), required=False, label='Site',
-        queryset=Site.objects.all(),
+                                      widget=forms.Select(attrs={'filter-for': 'nat_device'}))
-        required=False,
+    nat_device = forms.ModelChoiceField(queryset=Device.objects.all(), required=False, label='Device',
-        label='Site',
+                                        widget=APISelect(api_url='/api/dcim/devices/?site_id={{nat_site}}',
-        widget=forms.Select(
-            attrs={'filter-for': 'interface_rack'}
-        )
-    )
-    interface_rack = ChainedModelChoiceField(
-        queryset=Rack.objects.all(),
-        chains=(
-            ('site', 'interface_site'),
-        ),
-        required=False,
-        label='Rack',
-        widget=APISelect(
-            api_url='/api/dcim/racks/?site_id={{interface_site}}',
                                                          display_field='display_name',
-            attrs={'filter-for': 'interface_device', 'nullable': 'true'}
+                                                         attrs={'filter-for': 'nat_inside'}))
+    livesearch = forms.CharField(required=False, label='IP Address', widget=Livesearch(
+        query_key='q', query_url='ipam-api:ipaddress_list', field_to_update='nat_inside', obj_label='address')
     )
-    )
-    interface_device = ChainedModelChoiceField(
-        queryset=Device.objects.all(),
-        chains=(
-            ('site', 'interface_site'),
-            ('rack', 'interface_rack'),
-        ),
-        required=False,
-        label='Device',
-        widget=APISelect(
-            api_url='/api/dcim/devices/?site_id={{interface_site}}&rack_id={{interface_rack}}',
-            display_field='display_name',
-            attrs={'filter-for': 'interface'}
-        )
-    )
-    interface = ChainedModelChoiceField(
-        queryset=Interface.objects.all(),
-        chains=(
-            ('device', 'interface_device'),
-        ),
-        required=False,
-        widget=APISelect(
-            api_url='/api/dcim/interfaces/?device_id={{interface_device}}'
-        )
-    )
-    nat_site = forms.ModelChoiceField(
-        queryset=Site.objects.all(),
-        required=False,
-        label='Site',
-        widget=forms.Select(
-            attrs={'filter-for': 'nat_rack'}
-        )
-    )
-    nat_rack = ChainedModelChoiceField(
-        queryset=Rack.objects.all(),
-        chains=(
-            ('site', 'nat_site'),
-        ),
-        required=False,
-        label='Rack',
-        widget=APISelect(
-            api_url='/api/dcim/racks/?site_id={{nat_site}}',
-            display_field='display_name',
-            attrs={'filter-for': 'nat_device', 'nullable': 'true'}
-        )
-    )
-    nat_device = ChainedModelChoiceField(
-        queryset=Device.objects.all(),
-        chains=(
-            ('site', 'nat_site'),
-            ('rack', 'nat_rack'),
-        ),
-        required=False,
-        label='Device',
-        widget=APISelect(
-            api_url='/api/dcim/devices/?site_id={{nat_site}}&rack_id={{nat_rack}}',
-            display_field='display_name',
-            attrs={'filter-for': 'nat_inside'}
-        )
-    )
-    nat_inside = ChainedModelChoiceField(
-        queryset=IPAddress.objects.all(),
-        chains=(
-            ('interface__device', 'nat_device'),
-        ),
-        required=False,
-        label='IP Address',
-        widget=APISelect(
-            api_url='/api/ipam/ip-addresses/?device_id={{nat_device}}',
-            display_field='address'
-        )
-    )
-    livesearch = forms.CharField(
-        required=False,
-        label='Search',
-        widget=Livesearch(
-            query_key='q',
-            query_url='ipam-api:ipaddress-list',
-            field_to_update='nat_inside',
-            obj_label='address'
-        )
-    )
-    primary_for_device = forms.BooleanField(required=False, label='Make this the primary IP for the device')
 
     class Meta:
         model = IPAddress
-        fields = [
+        fields = ['address', 'vrf', 'tenant', 'status', 'nat_inside', 'description']
-            'address', 'vrf', 'status', 'role', 'description', 'interface', 'primary_for_device', 'nat_site', 'nat_rack',
+        widgets = {
-            'nat_inside', 'tenant_group', 'tenant',
+            'nat_inside': APISelect(api_url='/api/ipam/ip-addresses/?device_id={{nat_device}}', display_field='address')
-        ]
+        }
 
     def __init__(self, *args, **kwargs):
-
-        # Initialize helper selectors
-        instance = kwargs.get('instance')
-        initial = kwargs.get('initial', {})
-        if instance and instance.interface is not None:
-            initial['interface_site'] = instance.interface.device.site
-            initial['interface_rack'] = instance.interface.device.rack
-            initial['interface_device'] = instance.interface.device
-        if instance and instance.nat_inside and instance.nat_inside.device is not None:
-            initial['nat_site'] = instance.nat_inside.device.site
-            initial['nat_rack'] = instance.nat_inside.device.rack
-            initial['nat_device'] = instance.nat_inside.device
-        kwargs['initial'] = initial
-
         super(IPAddressForm, self).__init__(*args, **kwargs)
 
         self.fields['vrf'].empty_label = 'Global'
 
-        # Initialize primary_for_device if IP address is already assigned
+        if self.instance.nat_inside:
-        if self.instance.interface is not None:
-            device = self.instance.interface.device
-            if (
-                self.instance.address.version == 4 and device.primary_ip4 == self.instance or
-                self.instance.address.version == 6 and device.primary_ip6 == self.instance
-            ):
-                self.initial['primary_for_device'] = True
 
-    def clean(self):
+            nat_inside = self.instance.nat_inside
-        super(IPAddressForm, self).clean()
+            # If the IP is assigned to an interface, populate site/device fields accordingly
-
+            if self.instance.nat_inside.interface:
-        # Primary IP assignment is only available if an interface has been assigned.
+                self.initial['nat_site'] = self.instance.nat_inside.interface.device.site.pk
-        if self.cleaned_data.get('primary_for_device') and not self.cleaned_data.get('interface'):
+                self.initial['nat_device'] = self.instance.nat_inside.interface.device.pk
-            self.add_error(
+                self.fields['nat_device'].queryset = Device.objects.filter(
-                'primary_for_device', "Only IP addresses assigned to an interface can be designated as primary IPs."
+                    site=nat_inside.interface.device.site
+                )
+                self.fields['nat_inside'].queryset = IPAddress.objects.filter(
+                    interface__device=nat_inside.interface.device
                 )
-
-    def save(self, *args, **kwargs):
-
-        ipaddress = super(IPAddressForm, self).save(*args, **kwargs)
-
-        # Assign this IPAddress as the primary for the associated Device.
-        if self.cleaned_data['primary_for_device']:
-            device = self.cleaned_data['interface'].device
-            if ipaddress.address.version == 4:
-                device.primary_ip4 = ipaddress
             else:
-                device.primary_ip6 = ipaddress
+                self.fields['nat_inside'].queryset = IPAddress.objects.filter(pk=nat_inside.pk)
-            device.save()
 
-        # Clear assignment as primary for device if set.
         else:
-            try:
+
-                if ipaddress.address.version == 4:
+            # Initialize nat_device choices if nat_site is set
-                    device = ipaddress.primary_ip4_for
+            if self.is_bound and self.data.get('nat_site'):
-                    device.primary_ip4 = None
+                self.fields['nat_device'].queryset = Device.objects.filter(site__pk=self.data['nat_site'])
+            elif self.initial.get('nat_site'):
+                self.fields['nat_device'].queryset = Device.objects.filter(site=self.initial['nat_site'])
             else:
-                    device = ipaddress.primary_ip6_for
+                self.fields['nat_device'].choices = []
-                    device.primary_ip6 = None
-                device.save()
-            except Device.DoesNotExist:
-                pass
 
-        return ipaddress
+            # Initialize nat_inside choices if nat_device is set
+            if self.is_bound and self.data.get('nat_device'):
+                self.fields['nat_inside'].queryset = IPAddress.objects.filter(
+                    interface__device__pk=self.data['nat_device'])
+            elif self.initial.get('nat_device'):
+                self.fields['nat_inside'].queryset = IPAddress.objects.filter(
+                    interface__device__pk=self.initial['nat_device'])
+            else:
+                self.fields['nat_inside'].choices = []
 
 
-class IPAddressPatternForm(BootstrapMixin, forms.Form):
+class IPAddressBulkAddForm(BootstrapMixin, forms.Form):
-    pattern = ExpandableIPAddressField(label='Address pattern')
+    address = ExpandableIPAddressField()
+    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, label='VRF', empty_label='Global')
+    tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
+    status = forms.ChoiceField(choices=IPADDRESS_STATUS_CHOICES)
+    description = forms.CharField(max_length=100, required=False)
 
 
-class IPAddressBulkAddForm(BootstrapMixin, TenancyForm, CustomFieldForm):
+class IPAddressAssignForm(BootstrapMixin, forms.Form):
-
+    site = forms.ModelChoiceField(
-    class Meta:
+        queryset=Site.objects.all(),
-        model = IPAddress
+        label='Site',
-        fields = ['address', 'vrf', 'status', 'role', 'description', 'tenant_group', 'tenant']
+        required=False,
+        widget=forms.Select(
+            attrs={'filter-for': 'rack'}
+        )
+    )
+    rack = forms.ModelChoiceField(
+        queryset=Rack.objects.all(),
+        label='Rack',
+        required=False,
+        widget=APISelect(
+            api_url='/api/dcim/racks/?site_id={{site}}',
+            display_field='display_name',
+            attrs={'filter-for': 'device', 'nullable': 'true'}
+        )
+    )
+    device = forms.ModelChoiceField(
+        queryset=Device.objects.all(),
+        label='Device',
+        required=False,
+        widget=APISelect(
+            api_url='/api/dcim/devices/?site_id={{site}}&rack_id={{rack}}',
+            display_field='display_name',
+            attrs={'filter-for': 'interface'}
+        )
+    )
+    livesearch = forms.CharField(
+        required=False,
+        label='Device',
+        widget=Livesearch(
+            query_key='q',
+            query_url='dcim-api:device_list',
+            field_to_update='device'
+        )
+    )
+    interface = forms.ModelChoiceField(
+        queryset=Interface.objects.all(),
+        label='Interface',
+        widget=APISelect(
+            api_url='/api/dcim/devices/{{device}}/interfaces/'
+        )
+    )
+    set_as_primary = forms.BooleanField(
+        label='Set as primary IP for device',
+        required=False
+    )
 
     def __init__(self, *args, **kwargs):
-        super(IPAddressBulkAddForm, self).__init__(*args, **kwargs)
+
-        self.fields['vrf'].empty_label = 'Global'
+        super(IPAddressAssignForm, self).__init__(*args, **kwargs)
+
+        self.fields['rack'].choices = []
+        self.fields['device'].choices = []
+        self.fields['interface'].choices = []
 
 
-class IPAddressCSVForm(forms.ModelForm):
+class IPAddressFromCSVForm(forms.ModelForm):
-    vrf = forms.ModelChoiceField(
+    vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, to_field_name='rd',
-        queryset=VRF.objects.all(),
+                                 error_messages={'invalid_choice': 'VRF not found.'})
-        required=False,
+    tenant = forms.ModelChoiceField(Tenant.objects.all(), to_field_name='name', required=False,
-        to_field_name='rd',
+                                    error_messages={'invalid_choice': 'Tenant not found.'})
-        help_text='Route distinguisher of the assigned VRF',
+    status_name = forms.ChoiceField(choices=[(s[1], s[0]) for s in IPADDRESS_STATUS_CHOICES])
-        error_messages={
+    device = forms.ModelChoiceField(queryset=Device.objects.all(), required=False, to_field_name='name',
-            'invalid_choice': 'VRF not found.',
+                                    error_messages={'invalid_choice': 'Device not found.'})
-        }
+    interface_name = forms.CharField(required=False)
-    )
+    is_primary = forms.BooleanField(required=False)
-    tenant = forms.ModelChoiceField(
-        queryset=Tenant.objects.all(),
-        to_field_name='name',
-        required=False,
-        help_text='Name of the assigned tenant',
-        error_messages={
-            'invalid_choice': 'Tenant not found.',
-        }
-    )
-    status = CSVChoiceField(
-        choices=IPADDRESS_STATUS_CHOICES,
-        help_text='Operational status'
-    )
-    role = CSVChoiceField(
-        choices=IPADDRESS_ROLE_CHOICES,
-        required=False,
-        help_text='Functional role'
-    )
-    device = FlexibleModelChoiceField(
-        queryset=Device.objects.all(),
-        required=False,
-        to_field_name='name',
-        help_text='Name or ID of assigned device',
-        error_messages={
-            'invalid_choice': 'Device not found.',
-        }
-    )
-    interface_name = forms.CharField(
-        help_text='Name of assigned interface',
-        required=False
-    )
-    is_primary = forms.BooleanField(
-        help_text='Make this the primary IP for the assigned device',
-        required=False
-    )
 
     class Meta:
         model = IPAddress
-        fields = ['address', 'vrf', 'tenant', 'status', 'role', 'device', 'interface_name', 'is_primary', 'description']
+        fields = ['address', 'vrf', 'tenant', 'status_name', 'device', 'interface_name', 'is_primary', 'description']
 
     def clean(self):
 
-        super(IPAddressCSVForm, self).clean()
-
         device = self.cleaned_data.get('device')
         interface_name = self.cleaned_data.get('interface_name')
         is_primary = self.cleaned_data.get('is_primary')
@@ -630,39 +453,39 @@ class IPAddressCSVForm(forms.ModelForm):
         # Validate interface
         if device and interface_name:
             try:
-                self.instance.interface = Interface.objects.get(device=device, name=interface_name)
+                Interface.objects.get(device=device, name=interface_name)
             except Interface.DoesNotExist:
-                raise forms.ValidationError("Invalid interface {} for device {}".format(interface_name, device))
+                self.add_error('interface_name', "Invalid interface ({}) for {}".format(interface_name, device))
         elif device and not interface_name:
-            raise forms.ValidationError("Device set ({}) but interface missing".format(device))
+            self.add_error('interface_name', "Device set ({}) but interface missing".format(device))
         elif interface_name and not device:
-            raise forms.ValidationError("Interface set ({}) but device missing or invalid".format(interface_name))
+            self.add_error('device', "Interface set ({}) but device missing or invalid".format(interface_name))
 
         # Validate is_primary
         if is_primary and not device:
-            raise forms.ValidationError("No device specified; cannot set as primary IP")
+            self.add_error('is_primary', "No device specified; cannot set as primary IP")
 
     def save(self, *args, **kwargs):
 
+        # Assign status by name
+        self.instance.status = dict(self.fields['status_name'].choices)[self.cleaned_data['status_name']]
+
         # Set interface
         if self.cleaned_data['device'] and self.cleaned_data['interface_name']:
-            self.instance.interface = Interface.objects.get(
+            self.instance.interface = Interface.objects.get(device=self.cleaned_data['device'],
-                device=self.cleaned_data['device'],
+                                                            name=self.cleaned_data['interface_name'])
-                name=self.cleaned_data['interface_name']
-            )
-
-        ipaddress = super(IPAddressCSVForm, self).save(*args, **kwargs)
-
         # Set as primary for device
         if self.cleaned_data['is_primary']:
-            device = self.cleaned_data['device']
             if self.instance.address.version == 4:
-                device.primary_ip4 = ipaddress
+                self.instance.primary_ip4_for = self.cleaned_data['device']
             elif self.instance.address.version == 6:
-                device.primary_ip6 = ipaddress
+                self.instance.primary_ip6_for = self.cleaned_data['device']
-            device.save()
 
-        return ipaddress
+        return super(IPAddressFromCSVForm, self).save(*args, **kwargs)
+
+
+class IPAddressImportForm(BootstrapMixin, BulkImportForm):
+    csv = CSVDataField(csv_form=IPAddressFromCSVForm)
 
 
 class IPAddressBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
@@ -670,25 +493,17 @@ class IPAddressBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     vrf = forms.ModelChoiceField(queryset=VRF.objects.all(), required=False, label='VRF')
     tenant = forms.ModelChoiceField(queryset=Tenant.objects.all(), required=False)
     status = forms.ChoiceField(choices=add_blank_choice(IPADDRESS_STATUS_CHOICES), required=False)
-    role = forms.ChoiceField(choices=add_blank_choice(IPADDRESS_ROLE_CHOICES), required=False)
     description = forms.CharField(max_length=100, required=False)
 
     class Meta:
-        nullable_fields = ['vrf', 'role', 'tenant', 'description']
+        nullable_fields = ['vrf', 'tenant', 'description']
 
 
 def ipaddress_status_choices():
     status_counts = {}
     for status in IPAddress.objects.values('status').annotate(count=Count('status')).order_by('status'):
         status_counts[status['status']] = status['count']
-    return [(s[0], '{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in IPADDRESS_STATUS_CHOICES]
+    return [(s[0], u'{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in IPADDRESS_STATUS_CHOICES]
-
-
-def ipaddress_role_choices():
-    role_counts = {}
-    for role in IPAddress.objects.values('role').annotate(count=Count('role')).order_by('role'):
-        role_counts[role['role']] = role['count']
-    return [(r[0], '{} ({})'.format(r[1], role_counts.get(r[0], 0))) for r in IPADDRESS_ROLE_CHOICES]
 
 
 class IPAddressFilterForm(BootstrapMixin, CustomFieldFilterForm):
@@ -711,7 +526,6 @@ class IPAddressFilterForm(BootstrapMixin, CustomFieldFilterForm):
         null_option=(0, 'None')
     )
     status = forms.MultipleChoiceField(choices=ipaddress_status_choices, required=False)
-    role = forms.MultipleChoiceField(choices=ipaddress_role_choices, required=False)
 
 
 #
@@ -738,29 +552,14 @@ class VLANGroupFilterForm(BootstrapMixin, forms.Form):
 # VLANs
 #
 
-class VLANForm(BootstrapMixin, TenancyForm, CustomFieldForm):
+class VLANForm(BootstrapMixin, CustomFieldForm):
-    site = forms.ModelChoiceField(
+    group = forms.ModelChoiceField(queryset=VLANGroup.objects.all(), required=False, label='Group', widget=APISelect(
-        queryset=Site.objects.all(),
-        required=False,
-        widget=forms.Select(
-            attrs={'filter-for': 'group', 'nullable': 'true'}
-        )
-    )
-    group = ChainedModelChoiceField(
-        queryset=VLANGroup.objects.all(),
-        chains=(
-            ('site', 'site'),
-        ),
-        required=False,
-        label='Group',
-        widget=APISelect(
         api_url='/api/ipam/vlan-groups/?site_id={{site}}',
-        )
+    ))
-    )
 
     class Meta:
         model = VLAN
-        fields = ['site', 'group', 'vid', 'name', 'status', 'role', 'description', 'tenant_group', 'tenant']
+        fields = ['site', 'group', 'vid', 'name', 'tenant', 'status', 'role', 'description']
         help_texts = {
             'site': "Leave blank if this VLAN spans multiple sites",
             'group': "VLAN group (optional)",
@@ -769,69 +568,73 @@ class VLANForm(BootstrapMixin, TenancyForm, CustomFieldForm):
             'status': "Operational status of this VLAN",
             'role': "The primary function of this VLAN",
         }
+        widgets = {
+            'site': forms.Select(attrs={'filter-for': 'group', 'nullable': 'true'}),
+        }
+
+    def __init__(self, *args, **kwargs):
+
+        super(VLANForm, self).__init__(*args, **kwargs)
+
+        # Limit VLAN group choices
+        if self.is_bound and self.data.get('site'):
+            self.fields['group'].queryset = VLANGroup.objects.filter(site__pk=self.data['site'])
+        elif self.initial.get('site'):
+            self.fields['group'].queryset = VLANGroup.objects.filter(site=self.initial['site'])
+        else:
+            self.fields['group'].queryset = VLANGroup.objects.filter(site=None)
 
 
-class VLANCSVForm(forms.ModelForm):
+class VLANFromCSVForm(forms.ModelForm):
     site = forms.ModelChoiceField(
-        queryset=Site.objects.all(),
+        queryset=Site.objects.all(), required=False, to_field_name='name',
-        required=False,
+        error_messages={'invalid_choice': 'Site not found.'}
-        to_field_name='name',
-        help_text='Name of parent site',
-        error_messages={
-            'invalid_choice': 'Site not found.',
-        }
-    )
-    group_name = forms.CharField(
-        help_text='Name of VLAN group',
-        required=False
     )
+    group_name = forms.CharField(required=False)
     tenant = forms.ModelChoiceField(
-        queryset=Tenant.objects.all(),
+        Tenant.objects.all(), to_field_name='name', required=False,
-        to_field_name='name',
+        error_messages={'invalid_choice': 'Tenant not found.'}
-        required=False,
-        help_text='Name of assigned tenant',
-        error_messages={
-            'invalid_choice': 'Tenant not found.',
-        }
-    )
-    status = CSVChoiceField(
-        choices=VLAN_STATUS_CHOICES,
-        help_text='Operational status'
     )
+    status_name = forms.ChoiceField(choices=[(s[1], s[0]) for s in VLAN_STATUS_CHOICES])
     role = forms.ModelChoiceField(
-        queryset=Role.objects.all(),
+        queryset=Role.objects.all(), required=False, to_field_name='name',
-        required=False,
+        error_messages={'invalid_choice': 'Invalid role.'}
-        to_field_name='name',
-        help_text='Functional role',
-        error_messages={
-            'invalid_choice': 'Invalid role.',
-        }
     )
 
     class Meta:
         model = VLAN
-        fields = ['site', 'group_name', 'vid', 'name', 'tenant', 'status', 'role', 'description']
+        fields = ['site', 'group_name', 'vid', 'name', 'tenant', 'status_name', 'role', 'description']
-        help_texts = {
-            'vid': 'Numeric VLAN ID (1-4095)',
-            'name': 'VLAN name',
-        }
 
     def clean(self):
 
-        super(VLANCSVForm, self).clean()
+        super(VLANFromCSVForm, self).clean()
 
-        site = self.cleaned_data.get('site')
+        # Validate VLANGroup
         group_name = self.cleaned_data.get('group_name')
-
-        # Validate VLAN group
         if group_name:
             try:
-                self.instance.group = VLANGroup.objects.get(site=site, name=group_name)
+                vlan_group = VLANGroup.objects.get(site=self.cleaned_data.get('site'), name=group_name)
             except VLANGroup.DoesNotExist:
-                if site:
+                self.add_error('group_name', "Invalid VLAN group {}.".format(group_name))
-                    raise forms.ValidationError("VLAN group {} not found for site {}".format(group_name, site))
+
-                else:
+    def save(self, *args, **kwargs):
-                    raise forms.ValidationError("Global VLAN group {} not found".format(group_name))
+
+        vlan = super(VLANFromCSVForm, self).save(commit=False)
+
+        # Assign VLANGroup by site and name
+        if self.cleaned_data['group_name']:
+            vlan.group = VLANGroup.objects.get(site=self.cleaned_data['site'], name=self.cleaned_data['group_name'])
+
+        # Assign VLAN status by name
+        vlan.status = dict(self.fields['status_name'].choices)[self.cleaned_data['status_name']]
+
+        if kwargs.get('commit'):
+            vlan.save()
+        return vlan
+
+
+class VLANImportForm(BootstrapMixin, BulkImportForm):
+    csv = CSVDataField(csv_form=VLANFromCSVForm)
 
 
 class VLANBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
@@ -844,14 +647,14 @@ class VLANBulkEditForm(BootstrapMixin, CustomFieldBulkEditForm):
     description = forms.CharField(max_length=100, required=False)
 
     class Meta:
-        nullable_fields = ['site', 'group', 'tenant', 'role', 'description']
+        nullable_fields = ['group', 'tenant', 'role', 'description']
 
 
 def vlan_status_choices():
     status_counts = {}
     for status in VLAN.objects.values('status').annotate(count=Count('status')).order_by('status'):
         status_counts[status['status']] = status['count']
-    return [(s[0], '{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in VLAN_STATUS_CHOICES]
+    return [(s[0], u'{} ({})'.format(s[1], status_counts.get(s[0], 0))) for s in VLAN_STATUS_CHOICES]
 
 
 class VLANFilterForm(BootstrapMixin, CustomFieldFilterForm):

netbox/ipam/lookups.py

@@ -1,5 +1,3 @@
-from __future__ import unicode_literals
-
 from django.db.models import Lookup, Transform, IntegerField
 from django.db.models.lookups import BuiltinLookup
 

netbox/ipam/migrations/0016_unicode_literals.py

@@ -1,133 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11 on 2017-05-24 15:34
-from __future__ import unicode_literals
-
-import django.core.validators
-from django.db import migrations, models
-import django.db.models.deletion
-import ipam.fields
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('ipam', '0015_global_vlans'),
-    ]
-
-    operations = [
-        migrations.AlterField(
-            model_name='aggregate',
-            name='family',
-            field=models.PositiveSmallIntegerField(choices=[(4, 'IPv4'), (6, 'IPv6')]),
-        ),
-        migrations.AlterField(
-            model_name='aggregate',
-            name='rir',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.PROTECT, related_name='aggregates', to='ipam.RIR', verbose_name='RIR'),
-        ),
-        migrations.AlterField(
-            model_name='ipaddress',
-            name='address',
-            field=ipam.fields.IPAddressField(help_text='IPv4 or IPv6 address (with mask)'),
-        ),
-        migrations.AlterField(
-            model_name='ipaddress',
-            name='family',
-            field=models.PositiveSmallIntegerField(choices=[(4, 'IPv4'), (6, 'IPv6')], editable=False),
-        ),
-        migrations.AlterField(
-            model_name='ipaddress',
-            name='nat_inside',
-            field=models.OneToOneField(blank=True, help_text='The IP for which this address is the "outside" IP', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='nat_outside', to='ipam.IPAddress', verbose_name='NAT (Inside)'),
-        ),
-        migrations.AlterField(
-            model_name='ipaddress',
-            name='status',
-            field=models.PositiveSmallIntegerField(choices=[(1, 'Active'), (2, 'Reserved'), (3, 'Deprecated'), (5, 'DHCP')], default=1, verbose_name='Status'),
-        ),
-        migrations.AlterField(
-            model_name='ipaddress',
-            name='vrf',
-            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='ip_addresses', to='ipam.VRF', verbose_name='VRF'),
-        ),
-        migrations.AlterField(
-            model_name='prefix',
-            name='family',
-            field=models.PositiveSmallIntegerField(choices=[(4, 'IPv4'), (6, 'IPv6')], editable=False),
-        ),
-        migrations.AlterField(
-            model_name='prefix',
-            name='is_pool',
-            field=models.BooleanField(default=False, help_text='All IP addresses within this prefix are considered usable', verbose_name='Is a pool'),
-        ),
-        migrations.AlterField(
-            model_name='prefix',
-            name='prefix',
-            field=ipam.fields.IPNetworkField(help_text='IPv4 or IPv6 network with mask'),
-        ),
-        migrations.AlterField(
-            model_name='prefix',
-            name='role',
-            field=models.ForeignKey(blank=True, help_text='The primary function of this prefix', null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='prefixes', to='ipam.Role'),
-        ),
-        migrations.AlterField(
-            model_name='prefix',
-            name='status',
-            field=models.PositiveSmallIntegerField(choices=[(0, 'Container'), (1, 'Active'), (2, 'Reserved'), (3, 'Deprecated')], default=1, help_text='Operational status of this prefix', verbose_name='Status'),
-        ),
-        migrations.AlterField(
-            model_name='prefix',
-            name='vlan',
-            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='prefixes', to='ipam.VLAN', verbose_name='VLAN'),
-        ),
-        migrations.AlterField(
-            model_name='prefix',
-            name='vrf',
-            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.PROTECT, related_name='prefixes', to='ipam.VRF', verbose_name='VRF'),
-        ),
-        migrations.AlterField(
-            model_name='rir',
-            name='is_private',
-            field=models.BooleanField(default=False, help_text='IP space managed by this RIR is considered private', verbose_name='Private'),
-        ),
-        migrations.AlterField(
-            model_name='service',
-            name='device',
-            field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='services', to='dcim.Device', verbose_name='device'),
-        ),
-        migrations.AlterField(
-            model_name='service',
-            name='ipaddresses',
-            field=models.ManyToManyField(blank=True, related_name='services', to='ipam.IPAddress', verbose_name='IP addresses'),
-        ),
-        migrations.AlterField(
-            model_name='service',
-            name='port',
-            field=models.PositiveIntegerField(validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(65535)], verbose_name='Port number'),
-        ),
-        migrations.AlterField(
-            model_name='service',
-            name='protocol',
-            field=models.PositiveSmallIntegerField(choices=[(6, 'TCP'), (17, 'UDP')]),
-        ),
-        migrations.AlterField(
-            model_name='vlan',
-            name='status',
-            field=models.PositiveSmallIntegerField(choices=[(1, 'Active'), (2, 'Reserved'), (3, 'Deprecated')], default=1, verbose_name='Status'),
-        ),
-        migrations.AlterField(
-            model_name='vlan',
-            name='vid',
-            field=models.PositiveSmallIntegerField(validators=[django.core.validators.MinValueValidator(1), django.core.validators.MaxValueValidator(4094)], verbose_name='ID'),
-        ),
-        migrations.AlterField(
-            model_name='vrf',
-            name='enforce_unique',
-            field=models.BooleanField(default=True, help_text='Prevent duplicate prefixes/IP addresses within this VRF', verbose_name='Enforce unique space'),
-        ),
-        migrations.AlterField(
-            model_name='vrf',
-            name='rd',
-            field=models.CharField(max_length=21, unique=True, verbose_name='Route distinguisher'),
-        ),
-    ]

netbox/ipam/migrations/0017_ipaddress_roles.py

@@ -1,25 +0,0 @@
-# -*- coding: utf-8 -*-
-# Generated by Django 1.11.1 on 2017-06-16 19:37
-from __future__ import unicode_literals
-
-from django.db import migrations, models
-
-
-class Migration(migrations.Migration):
-
-    dependencies = [
-        ('ipam', '0016_unicode_literals'),
-    ]
-
-    operations = [
-        migrations.AddField(
-            model_name='ipaddress',
-            name='role',
-            field=models.PositiveSmallIntegerField(blank=True, choices=[(10, 'Loopback'), (20, 'Secondary'), (30, 'Anycast'), (40, 'VIP'), (41, 'VRRP'), (42, 'HSRP'), (43, 'GLBP')], help_text='The functional role of this IP', null=True, verbose_name='Role'),
-        ),
-        migrations.AlterField(
-            model_name='ipaddress',
-            name='status',
-            field=models.PositiveSmallIntegerField(choices=[(1, 'Active'), (2, 'Reserved'), (3, 'Deprecated'), (5, 'DHCP')], default=1, help_text='The operational status of this IP', verbose_name='Status'),
-        ),
-    ]

netbox/ipam/models.py

@@ -1,13 +1,12 @@
-from __future__ import unicode_literals
+from netaddr import IPNetwork, cidr_merge
-import netaddr
 
 from django.conf import settings
 from django.contrib.contenttypes.fields import GenericRelation
 from django.core.exceptions import ValidationError
+from django.core.urlresolvers import reverse
 from django.core.validators import MaxValueValidator, MinValueValidator
 from django.db import models
 from django.db.models.expressions import RawSQL
-from django.urls import reverse
 from django.utils.encoding import python_2_unicode_compatible
 
 from dcim.models import Interface
@@ -16,10 +15,64 @@ from tenancy.models import Tenant
 from utilities.models import CreatedUpdatedModel
 from utilities.sql import NullsFirstQuerySet
 from utilities.utils import csv_format
-from .constants import *
+
 from .fields import IPNetworkField, IPAddressField
 
 
+AF_CHOICES = (
+    (4, 'IPv4'),
+    (6, 'IPv6'),
+)
+
+PREFIX_STATUS_CONTAINER = 0
+PREFIX_STATUS_ACTIVE = 1
+PREFIX_STATUS_RESERVED = 2
+PREFIX_STATUS_DEPRECATED = 3
+PREFIX_STATUS_CHOICES = (
+    (PREFIX_STATUS_CONTAINER, 'Container'),
+    (PREFIX_STATUS_ACTIVE, 'Active'),
+    (PREFIX_STATUS_RESERVED, 'Reserved'),
+    (PREFIX_STATUS_DEPRECATED, 'Deprecated')
+)
+
+IPADDRESS_STATUS_ACTIVE = 1
+IPADDRESS_STATUS_RESERVED = 2
+IPADDRESS_STATUS_DEPRECATED = 3
+IPADDRESS_STATUS_DHCP = 5
+IPADDRESS_STATUS_CHOICES = (
+    (IPADDRESS_STATUS_ACTIVE, 'Active'),
+    (IPADDRESS_STATUS_RESERVED, 'Reserved'),
+    (IPADDRESS_STATUS_DEPRECATED, 'Deprecated'),
+    (IPADDRESS_STATUS_DHCP, 'DHCP')
+)
+
+VLAN_STATUS_ACTIVE = 1
+VLAN_STATUS_RESERVED = 2
+VLAN_STATUS_DEPRECATED = 3
+VLAN_STATUS_CHOICES = (
+    (VLAN_STATUS_ACTIVE, 'Active'),
+    (VLAN_STATUS_RESERVED, 'Reserved'),
+    (VLAN_STATUS_DEPRECATED, 'Deprecated')
+)
+
+STATUS_CHOICE_CLASSES = {
+    0: 'default',
+    1: 'primary',
+    2: 'info',
+    3: 'danger',
+    4: 'warning',
+    5: 'success',
+}
+
+
+IP_PROTOCOL_TCP = 6
+IP_PROTOCOL_UDP = 17
+IP_PROTOCOL_CHOICES = (
+    (IP_PROTOCOL_TCP, 'TCP'),
+    (IP_PROTOCOL_UDP, 'UDP'),
+)
+
+
 @python_2_unicode_compatible
 class VRF(CreatedUpdatedModel, CustomFieldModel):
     """
@@ -35,15 +88,13 @@ class VRF(CreatedUpdatedModel, CustomFieldModel):
     description = models.CharField(max_length=100, blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
 
-    csv_headers = ['name', 'rd', 'tenant', 'enforce_unique', 'description']
-
     class Meta:
         ordering = ['name']
         verbose_name = 'VRF'
         verbose_name_plural = 'VRFs'
 
     def __str__(self):
-        return self.display_name or super(VRF, self).__str__()
+        return self.name
 
     def get_absolute_url(self):
         return reverse('ipam:vrf', args=[self.pk])
@@ -57,12 +108,6 @@ class VRF(CreatedUpdatedModel, CustomFieldModel):
             self.description,
         ])
 
-    @property
-    def display_name(self):
-        if self.name and self.rd:
-            return "{} ({})".format(self.name, self.rd)
-        return None
-
 
 @python_2_unicode_compatible
 class RIR(models.Model):
@@ -100,8 +145,6 @@ class Aggregate(CreatedUpdatedModel, CustomFieldModel):
     description = models.CharField(max_length=100, blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
 
-    csv_headers = ['prefix', 'rir', 'date_added', 'description']
-
     class Meta:
         ordering = ['family', 'prefix']
 
@@ -156,11 +199,15 @@ class Aggregate(CreatedUpdatedModel, CustomFieldModel):
 
     def get_utilization(self):
         """
-        Determine the prefix utilization of the aggregate and return it as a percentage.
+        Determine the utilization rate of the aggregate prefix and return it as a percentage.
         """
-        queryset = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))
+        child_prefixes = Prefix.objects.filter(prefix__net_contained_or_equal=str(self.prefix))
-        child_prefixes = netaddr.IPSet([p.prefix for p in queryset])
+        # Remove overlapping prefixes from list of children
-        return int(float(child_prefixes.size) / self.prefix.size * 100)
+        networks = cidr_merge([c.prefix for c in child_prefixes])
+        children_size = float(0)
+        for p in networks:
+            children_size += p.size
+        return int(children_size / self.prefix.size * 100)
 
 
 @python_2_unicode_compatible
@@ -249,10 +296,6 @@ class Prefix(CreatedUpdatedModel, CustomFieldModel):
 
     objects = PrefixQuerySet.as_manager()
 
-    csv_headers = [
-        'prefix', 'vrf', 'tenant', 'site', 'vlan_group', 'vlan_vid', 'status', 'role', 'is_pool', 'description',
-    ]
-
     class Meta:
         ordering = ['vrf', 'family', 'prefix']
         verbose_name_plural = 'prefixes'
@@ -263,6 +306,9 @@ class Prefix(CreatedUpdatedModel, CustomFieldModel):
     def get_absolute_url(self):
         return reverse('ipam:prefix', args=[self.pk])
 
+    def get_duplicates(self):
+        return Prefix.objects.filter(vrf=self.vrf, prefix=str(self.prefix)).exclude(pk=self.pk)
+
     def clean(self):
 
         if self.prefix:
@@ -310,64 +356,20 @@ class Prefix(CreatedUpdatedModel, CustomFieldModel):
             self.description,
         ])
 
-    def get_status_class(self):
-        return STATUS_CHOICE_CLASSES[self.status]
-
-    def get_duplicates(self):
-        return Prefix.objects.filter(vrf=self.vrf, prefix=str(self.prefix)).exclude(pk=self.pk)
-
-    def get_child_ips(self):
-        """
-        Return all IPAddresses within this Prefix.
-        """
-        return IPAddress.objects.filter(address__net_contained_or_equal=str(self.prefix), vrf=self.vrf)
-
-    def get_available_ips(self):
-        """
-        Return all available IPs within this prefix as an IPSet.
-        """
-        prefix = netaddr.IPSet(self.prefix)
-        child_ips = netaddr.IPSet([ip.address.ip for ip in self.get_child_ips()])
-        available_ips = prefix - child_ips
-
-        # Remove unusable IPs from non-pool prefixes
-        if not self.is_pool:
-            available_ips -= netaddr.IPSet([
-                netaddr.IPAddress(self.prefix.first),
-                netaddr.IPAddress(self.prefix.last),
-            ])
-
-        return available_ips
-
-    def get_utilization(self):
-        """
-        Determine the utilization of the prefix and return it as a percentage. For Prefixes with a status of
-        "container", calculate utilization based on child prefixes. For all others, count child IP addresses.
-        """
-        if self.status == PREFIX_STATUS_CONTAINER:
-            queryset = Prefix.objects.filter(prefix__net_contained=str(self.prefix), vrf=self.vrf)
-            child_prefixes = netaddr.IPSet([p.prefix for p in queryset])
-            return int(float(child_prefixes.size) / self.prefix.size * 100)
-        else:
-            child_count = IPAddress.objects.filter(
-                address__net_contained_or_equal=str(self.prefix), vrf=self.vrf
-            ).count()
-            prefix_size = self.prefix.size
-            if self.family == 4 and self.prefix.prefixlen < 31 and not self.is_pool:
-                prefix_size -= 2
-            return int(float(child_count) / prefix_size * 100)
-
     @property
     def new_subnet(self):
         if self.family == 4:
             if self.prefix.prefixlen <= 30:
-                return netaddr.IPNetwork('{}/{}'.format(self.prefix.network, self.prefix.prefixlen + 1))
+                return IPNetwork('{}/{}'.format(self.prefix.network, self.prefix.prefixlen + 1))
             return None
         if self.family == 6:
             if self.prefix.prefixlen <= 126:
-                return netaddr.IPNetwork('{}/{}'.format(self.prefix.network, self.prefix.prefixlen + 1))
+                return IPNetwork('{}/{}'.format(self.prefix.network, self.prefix.prefixlen + 1))
             return None
 
+    def get_status_class(self):
+        return STATUS_CHOICE_CLASSES[self.status]
+
 
 class IPAddressManager(models.Manager):
 
@@ -400,13 +402,7 @@ class IPAddress(CreatedUpdatedModel, CustomFieldModel):
     vrf = models.ForeignKey('VRF', related_name='ip_addresses', on_delete=models.PROTECT, blank=True, null=True,
                             verbose_name='VRF')
     tenant = models.ForeignKey(Tenant, related_name='ip_addresses', blank=True, null=True, on_delete=models.PROTECT)
-    status = models.PositiveSmallIntegerField(
+    status = models.PositiveSmallIntegerField('Status', choices=IPADDRESS_STATUS_CHOICES, default=1)
-        'Status', choices=IPADDRESS_STATUS_CHOICES, default=IPADDRESS_STATUS_ACTIVE,
-        help_text='The operational status of this IP'
-    )
-    role = models.PositiveSmallIntegerField(
-        'Role', choices=IPADDRESS_ROLE_CHOICES, blank=True, null=True, help_text='The functional role of this IP'
-    )
     interface = models.ForeignKey(Interface, related_name='ip_addresses', on_delete=models.CASCADE, blank=True,
                                   null=True)
     nat_inside = models.OneToOneField('self', related_name='nat_outside', on_delete=models.SET_NULL, blank=True,
@@ -417,10 +413,6 @@ class IPAddress(CreatedUpdatedModel, CustomFieldModel):
 
     objects = IPAddressManager()
 
-    csv_headers = [
-        'address', 'vrf', 'tenant', 'status', 'role', 'device', 'interface_name', 'is_primary', 'description',
-    ]
-
     class Meta:
         ordering = ['family', 'address']
         verbose_name = 'IP address'
@@ -459,19 +451,17 @@ class IPAddress(CreatedUpdatedModel, CustomFieldModel):
     def to_csv(self):
 
         # Determine if this IP is primary for a Device
+        is_primary = False
         if self.family == 4 and getattr(self, 'primary_ip4_for', False):
             is_primary = True
         elif self.family == 6 and getattr(self, 'primary_ip6_for', False):
             is_primary = True
-        else:
-            is_primary = False
 
         return csv_format([
             self.address,
             self.vrf.rd if self.vrf else None,
             self.tenant.name if self.tenant else None,
             self.get_status_display(),
-            self.get_role_display(),
             self.device.identifier if self.device else None,
             self.interface.name if self.interface else None,
             is_primary,
@@ -507,7 +497,9 @@ class VLANGroup(models.Model):
         verbose_name_plural = 'VLAN groups'
 
     def __str__(self):
+        if self.site is None:
             return self.name
+        return u'{} - {}'.format(self.site.name, self.name)
 
     def get_absolute_url(self):
         return "{}?group_id={}".format(reverse('ipam:vlan_list'), self.pk)
@@ -536,8 +528,6 @@ class VLAN(CreatedUpdatedModel, CustomFieldModel):
     description = models.CharField(max_length=100, blank=True)
     custom_field_values = GenericRelation(CustomFieldValue, content_type_field='obj_type', object_id_field='obj_id')
 
-    csv_headers = ['site', 'group_name', 'vid', 'name', 'tenant', 'status', 'role', 'description']
-
     class Meta:
         ordering = ['site', 'group', 'vid']
         unique_together = [
@@ -548,7 +538,7 @@ class VLAN(CreatedUpdatedModel, CustomFieldModel):
         verbose_name_plural = 'VLANs'
 
     def __str__(self):
-        return self.display_name or super(VLAN, self).__str__()
+        return self.display_name
 
     def get_absolute_url(self):
         return reverse('ipam:vlan', args=[self.pk])
@@ -575,9 +565,7 @@ class VLAN(CreatedUpdatedModel, CustomFieldModel):
 
     @property
     def display_name(self):
-        if self.vid and self.name:
+        return u'{} ({})'.format(self.vid, self.name)
-            return "{} ({})".format(self.vid, self.name)
-        return None
 
     def get_status_class(self):
         return STATUS_CHOICE_CLASSES[self.status]
@@ -603,4 +591,4 @@ class Service(CreatedUpdatedModel):
         unique_together = ['device', 'protocol', 'port']
 
     def __str__(self):
-        return '{} ({}/{})'.format(self.name, self.port, self.get_protocol_display())
+        return u'{} ({}/{})'.format(self.name, self.port, self.get_protocol_display())