Working first version

Author: clittle

layers/README.md

@@ -18,6 +18,13 @@ This folder contains modules and scripts for working with ATT&CK Navigator layer
 |:-------|:------------|
 | [layerops](manipulators/layerops.py) | Provides a means by which to combine multiple ATT&CK layer objects in customized ways. A further breakdown can be found in the corresponding section below. |
 
+#### Exporter Scripts
+| script | description |
+|:-------|:------------|
+| [matrix_gen](exporters/matrix_gen.py) | Provides a means by which to generate a matrix from raw data, either cached or from the ATT&CK TAXII server. |
+| [excel_templates](exporters/excel_templates.py) | Provides a means by which to convert a matrix into a base excel template. |
+| [to_excel](exporters/to_excel.py) | Provides a means by which to export an ATT&CK Layer to an excel file. A further breakdown can be found in the corresponding section below. |
+
 ## Layer
 The Layer class provides format validation and read/write capabilities to aid in working with ATT&CK Navigator Layers in python. It is the primary interface through which other Layer-related classes defined in the core module should be used. The Layer class API and a usage example are below.
 
@@ -119,3 +126,19 @@ lo4 = LayerOps(score=lambda x: '; '.join(x),
 out_layer6 = lo4.process([demo2, demo3])                      # Trigger processing on a list of demo2 and demo0
 out_layer6.to_file("C:\demo_layer6.json")                     # Save combined comment layer to file
 ```
+
+## to_excel.py
+to_excel.py provides the ToExcel class, which is a way to export an existing layer file as an Excel spreadsheet. The ToExcel class has an optional parameter for the export function, `to_file()`, that tells the exporter to build the output matrix based on live data from cti-taxii.mitre.org. Otherwise, it will use the cached subtechniques data. If matrix template lacks elements included in a layer's technique listing, those elements will not be visible in the output file.
+#### Example Usage
+```python
+from layers import Layer
+from layers import ToExcel
+
+lay = Layer()
+lay.from_file("path/to/layer/file.json")
+t = ToExcel(lay)
+# Using cached data for template
+t.to_file("demo.xlsx")
+# Using live data for templates
+t.to_file("demo2.xlsx", fresh=True)
+```

layers/__init__.py

@@ -0,0 +1,3 @@
+from .core import *
+from .exporters import *
+from .manipulators import *

layers/core/gradient.py

@@ -1,3 +1,5 @@
+import colour
+import math
 try:
     from ..core.exceptions import typeChecker, typeCheckerArray
 except ValueError:
@@ -13,6 +15,8 @@ def __init__(self, colors, minValue, maxValue):
             :param minValue: The minValue for this gradient
             :param maxValue: The maxValue for this gradient
         """
+        self.__minValue = None
+        self.__maxValue = None
         self.colors = colors
         self.minValue = minValue
         self.maxValue = maxValue
@@ -27,6 +31,7 @@ def colors(self, colors):
         self.__colors = []
         for entry in colors:
             self.__colors.append(entry)
+        self._compute_curve()
 
     @property
     def minValue(self):
@@ -36,6 +41,7 @@ def minValue(self):
     def minValue(self, minValue):
         typeChecker(type(self).__name__, minValue, int, "minValue")
         self.__minValue = minValue
+        self._compute_curve()
 
     @property
     def maxValue(self):
@@ -45,6 +51,39 @@ def maxValue(self):
     def maxValue(self, maxValue):
         typeChecker(type(self).__name__, maxValue, int, "maxValue")
         self.__maxValue = maxValue
+        self._compute_curve()
+
+    def _compute_curve(self):
+        """
+            Computes the gradient color curve
+        """
+        if self.maxValue is not None and self.minValue is not None and self.colors is not None:
+            if len(self.colors) == 2:
+                s_c = colour.Color(self.colors[0])
+                e_c = colour.Color(self.colors[1])
+                self.curve = list(s_c.range_to(e_c, self.maxValue - self.minValue))
+            else:
+                s_c = colour.Color(self.colors[0])
+                m_c = colour.Color(self.colors[1])
+                e_c = colour.Color(self.colors[2])
+                self.curve = list(s_c.range_to(m_c, int(math.floor(self.maxValue - self.minValue)/2)))
+                curve_2 = list(m_c.range_to(e_c, int(math.ceil(self.maxValue - self.minValue)/2)))
+                self.curve.extend(curve_2)
+
+    def compute_color(self, score):
+        """
+            Computes a specific color based on the score value provided
+            :returns: A hexadecimal color representation of the score on
+                the gradient
+        """
+        if score <= self.minValue:
+            return self.colors[0]
+        if score >= self.maxValue:
+            return self.colors[-1]
+
+        target = self.curve[score - self.minValue]
+        return target.hex_l
+
 
     def get_dict(self):
         """

layers/core/technique.py

@@ -50,7 +50,7 @@ def tactic(self, tactic):
 
     @property
     def comment(self):
-        if self.__tactic != UNSETVALUE:
+        if self.__comment != UNSETVALUE:
             return self.__comment
 
     @comment.setter

layers/exporters/__init__.py

@@ -0,0 +1,3 @@
+from .excel_templates import ExcelTemplates
+from .matrix_gen import MatrixGen
+from .to_excel import ToExcel