Use ChoiceFieldColumns on tables

Author: jeremystretch

images/step05-accesslist-list.png

@@ -239,14 +239,39 @@ class ProtocolChoices(ChoiceSet):
 Then, add the `choices` keyword argument to the `protocol` field:
 
 ```python
-# AccessListRule
+    # AccessListRule
     protocol = models.CharField(
         max_length=30,
         choices=ProtocolChoices,
         blank=True
     )
 ```
 
+### Add Choice Color Methods
+
+Now that we've defined choices for some of our model fields, we'll need to provide a method for returning the appropriate color for a selected choice. This works similar to Django's `get_FOO_display()` methods, but returns a color (defined on the field's `ChoiceSet`) rather than a label. This method will be called e.g. when displaying the field in a table.
+
+Let's add a `get_default_action_color()` method on `AccessList`:
+
+```python
+class AccessList(NetBoxModel):
+    # ...
+    def get_default_action_color(self):
+        return ActionChoices.colors.get(self.default_action)
+```
+
+We also need to add methods for `protocol` and `action` on `AccessListRule`:
+
+```python
+class AccessListRule(NetBoxModel):
+    # ...
+    def get_protocol_color(self):
+        return ProtocolChoices.colors.get(self.protocol)
+
+    def get_action_color(self):
+        return ActionChoices.colors.get(self.action)
+```
+
 ## Create Schema Migrations
 
 Now that we have our models defined, we need to generate a schema for the PostgreSQL database. While it's possible to create the tables and constraints by hand, it's _much_ easier to employ Django's [migrations feature](https://docs.djangoproject.com/en/4.0/topics/migrations/). This will inspect our model classes and generate the necessary migration files automatically. This is a two-step process: First we generate the migration file with the `makemigrations` management command, then we run `migrate` to apply it to the live database.

images/step06-accesslist2.png

@@ -15,12 +15,12 @@ $ cd netbox_access_lists/
 $ edit tables.py
 ```
 
-At the top of this file, import the `django-tables2` library, as well as NetBox's `NetBoxTable` class. The latter will serve as the base class for our tables. We'll also import our plugin's models from `models.py`.
+At the top of this file, import the `django-tables2` library. This will provide the column classes for fields we wish to customize. We'll also import NetBox's `NetBoxTable` class, which will serve as the base class for our tables, and `ChoiceFieldColumn`. Finally we import our plugin's models from `models.py`.
 
 ```python
 import django_tables2 as tables
 
-from netbox.tables import NetBoxTable
+from netbox.tables import NetBoxTable, ChoiceFieldColumn
 from .models import AccessList, AccessListRule
 ```
 
@@ -50,13 +50,20 @@ class AccessListTable(NetBoxTable):
     )
 ```
 
+Also, recall that the `default_action` field on the `AccessList` model is a choice field, with a color assigned to each choice. To display these values, we'll use NetBox's `ChoiceFieldColumn` class.
+
+```python
+    default_action = ChoiceFieldColumn()
+```
+
 It would also be nice to include a count showing the number of rules each access list has assigned to it. We can add a custom column named `rule_count` to show this. (The data for this column will be annotated by the view; more on this in step five.) We'll also need to add this column to our `fields` and (optionally) `default_columns` under the `Meta` subclass. Our finished table should look like this:
 
 ```python
 class AccessListTable(NetBoxTable):
     name = tables.Column(
         linkify=True
     )
+    default_action = ChoiceFieldColumn()
     rule_count = tables.Column()
 
     class Meta(NetBoxTable.Meta):
@@ -67,7 +74,7 @@ class AccessListTable(NetBoxTable):
 
 ### AccessListRuleTable
 
-We'll also create a table for our `AccessListRule` model using the same approach as above. In this case, we don't need to add any custom columns, but we do want to linkify the `access_list` and `index` columns. The former will link to the parent access list, and the latter will link to the individual rule.
+We'll also create a table for our `AccessListRule` model using the same approach as above. Start by linkifying the `access_list` and `index` columns. The former will link to the parent access list, and the latter will link to the individual rule. We also want to declare `protocol` and `action` as `ChoiceFieldColumn` instances.
 
 ```python
 class AccessListRuleTable(NetBoxTable):
@@ -77,6 +84,8 @@ class AccessListRuleTable(NetBoxTable):
     index = tables.Column(
         linkify=True
     )
+    protocol = ChoiceFieldColumn()
+    action = ChoiceFieldColumn()
 
     class Meta(NetBoxTable.Meta):
         model = AccessListRule