Add indexes and events to dragonflow model printer

Add the ability to print the events and the indexes of a model in
addition to the (already existing) fields.

Change-Id: Iffcc7604e0c9426f0b262471b9a9292f7a809ace
Partial-Bug: #1734146

dragonflow/cli/df_model.py

@@ -76,6 +76,48 @@ class ModelsPrinter(object):
         """
         pass
 
+    def indexes_start(self):
+        """
+        Called once for every model, before all indexes.
+        Not called if no indexes exist
+        """
+        pass
+
+    def indexes_end(self):
+        """
+        Called once for every model, after all indexes.
+        Not called if no indexes exist
+        """
+        pass
+
+    @abc.abstractmethod
+    def handle_index(self, index_name):
+        """
+        Called once for every index in a model.
+        """
+        pass
+
+    def events_start(self):
+        """
+        Called once for every model, before all events.
+        Not called if no events exist
+        """
+        pass
+
+    def events_end(self):
+        """
+        Called once for every model, after all events.
+        Not called if no events exist
+        """
+        pass
+
+    @abc.abstractmethod
+    def handle_event(self, event_name):
+        """
+        Called once for every event in a model.
+        """
+        pass
+
 
 class PlaintextPrinter(ModelsPrinter):
     def __init__(self, fh):
@@ -101,6 +143,20 @@ class PlaintextPrinter(ModelsPrinter):
             embedded=', Embedded' if is_embedded else ''),
             file=self._output)
 
+    def indexes_start(self):
+        print('Indexes', file=self._output)
+        print('-------', file=self._output)
+
+    def handle_index(self, index_name):
+        print('{}'.format(index_name), file=self._output)
+
+    def events_start(self):
+        print('Events', file=self._output)
+        print('------', file=self._output)
+
+    def handle_event(self, event_name):
+        print('{}'.format(event_name), file=self._output)
+
 
 class UMLPrinter(ModelsPrinter):
     def __init__(self, fh):
@@ -111,6 +167,7 @@ class UMLPrinter(ModelsPrinter):
 
     def output_start(self):
         print('@startuml', file=self._output)
+        print('hide circle', file=self._output)
 
     def _output_relations(self):
         for (dst, src, name, is_single, is_embedded) in self._dependencies:
@@ -145,6 +202,18 @@ class UMLPrinter(ModelsPrinter):
         self._dependencies.add((self._model, type_, name_, is_single,
                                 is_embedded))
 
+    def indexes_start(self):
+        print('  .. Indexes ..', file=self._output)
+
+    def handle_index(self, index_name):
+        print(' {}'.format(index_name), file=self._output)
+
+    def events_start(self):
+        print('  == Events ==', file=self._output)
+
+    def handle_event(self, event_name):
+        print('  {}'.format(event_name), file=self._output)
+
 
 class DfModelParser(object):
     def __init__(self, printer):
@@ -173,37 +242,63 @@ class DfModelParser(object):
         else:
             return field.__name__, None
 
+    def _process_field(self, key, field):
+        if isinstance(field, field_types.ListOfField):
+            is_single = False
+            is_embedded = not isinstance(field,
+                                         field_types.ReferenceListField)
+            field_type, restrictions = self._stringify_field_type(field.field)
+        elif isinstance(field, fields.ListField):
+            is_single = False
+            is_embedded = False
+            field_type, restrictions = self._stringify_field_type(
+                field.items_types[0])
+            if isinstance(field, field_types.EnumListField):
+                restrictions = list(field._valid_values)
+        elif isinstance(field, fields.EmbeddedField):
+            is_single = True
+            is_embedded = True
+            field_type, restrictions = self._stringify_field_type(
+                field.types[0])
+        else:
+            is_single = True
+            is_embedded = False
+            field_type, restrictions = self._stringify_field_type(field)
+
+        field_type = re.sub('Field$', '', field_type)
+        self._printer.handle_field(key, field_type, is_embedded,
+                                   is_single, restrictions)
+
+    def _process_fields(self, df_model):
+        self._printer.fields_start()
+        for key, field in df_model.iterate_over_fields():
+            self._process_field(key, field)
+        self._printer.fields_end()
+
+    def _process_indexes(self, df_model):
+        model_indexes = df_model.get_indexes()
+        if len(model_indexes) > 0:
+            self._printer.indexes_start()
+            for key in model_indexes:
+                self._printer.handle_index(key)
+            self._printer.indexes_end()
+
+    def _process_events(self, df_model):
+        model_events = df_model.get_events()
+        if len(model_events) > 0:
+            self._printer.events_start()
+            for event in model_events:
+                self._printer.handle_event(event)
+            self._printer.events_end()
+
     def _process_model(self, df_model):
         model_name = df_model.__name__
         self._printer.model_start(model_name)
 
-        for key, field in df_model.iterate_over_fields():
-            if isinstance(field, field_types.ListOfField):
-                is_single = False
-                is_embedded = not isinstance(field,
-                                             field_types.ReferenceListField)
-                field_type, restrictions = self._stringify_field_type(
-                    field.field)
-            elif isinstance(field, fields.ListField):
-                is_single = False
-                is_embedded = False
-                field_type, restrictions = self._stringify_field_type(
-                    field.items_types[0])
-                if isinstance(field, field_types.EnumListField):
-                    restrictions = list(field._valid_values)
-            elif isinstance(field, fields.EmbeddedField):
-                is_single = True
-                is_embedded = True
-                field_type, restrictions = self._stringify_field_type(
-                    field.types[0])
-            else:
-                is_single = True
-                is_embedded = False
-                field_type, restrictions = self._stringify_field_type(field)
+        self._process_fields(df_model)
+        self._process_indexes(df_model)
+        self._process_events(df_model)
 
-            field_type = re.sub('Field$', '', field_type)
-            self._printer.handle_field(key, field_type, is_embedded,
-                                       is_single, restrictions)
         self._printer.model_end(model_name)
 
     def parse_models(self):