merge result set grouping from hplattner

composer/report/base.py

@@ -134,8 +134,8 @@ class Report(Template):
     def getPresentationFormats(self):
         return [dict(renderer='default', title='Default')]
     
-    def getCategoryFields(self):
-        return [f for f in self.fields if 'category' in f.executionSteps]
+    def getGroupFields(self):
+        return [f for f in self.fields if 'group' in f.executionSteps]
 
 
 class BaseQueryCriteria(Component):

composer/report/result.py

@@ -54,39 +54,43 @@ class Row(BaseRow):
     def getContextAttr(obj, attr):
         return getattr(obj.context, attr)
 
-    def getCategories(self):
+    def getGroupFields(self):
         return [self.getRawValue(f.name) for f in 
-                    self.parent.context.fields if 'category' in f.executionSteps]
+                    self.parent.context.fields if 'group' in f.executionSteps]
 
 
 class ResultSet(object):
 
-    def __init__(self, context, data, rowFactory=Row,
-                 sortCriteria=None, queryCriteria=BaseQueryCriteria(),
-                 filterDuplicates=False):
+    def __init__(self, context, data, rowFactory=Row, headerRowFactory=Row,
+                 sortCriteria=None, queryCriteria=BaseQueryCriteria()):
         self.context = context  # the report or report instance
         self.data = data
         self.rowFactory = rowFactory
+        self.headerRowFactory = headerRowFactory
         self.sortCriteria = sortCriteria
         self.queryCriteria = queryCriteria
-        self.filterDuplicates = filterDuplicates
         self.totals = BaseRow(None, self)
 
-    def filterDuplicateRows(self, result):
-        seen = set()
-        for row in result:
-            cats = tuple(row.getRawValue(f.name) for f in self.categoryColumns)
-            if cats not in seen:
-                seen.add(cats)
-                yield row
+    def insertHeaderRow(self, idx, result):
+        result.insert(idx, self.headerRowFactory(result[idx].context, self))
 
     def getResult(self):
         result = [self.rowFactory(item, self) for item in self.data]
-        if self.filterDuplicates:
-            result = self.filterDuplicateRows(result)
         result = [row for row in result if self.queryCriteria.check(row)]
         if self.sortCriteria:
             result.sort(key=lambda x: [f.getSortValue(x) for f in self.sortCriteria])
+        if self.groupColumns:
+            for idx, row in enumerate(result):
+                insert = False
+                for f in self.groupColumns:
+                    if idx == 0:
+                        insert = True
+                    else:
+                        if (result[idx].getRawValue(f.name) !=
+                                result[idx-1].getRawValue(f.name)):
+                            insert = True
+                if insert:
+                    self.insertHeaderRow(idx, result)
         for idx, row in enumerate(result):
             row.sequenceNumber = idx + 1
         return result
@@ -99,8 +103,8 @@ class ResultSet(object):
         return self.context.getActiveOutputFields()
 
     @Lazy
-    def categoryColumns(self):
-        return self.context.getCategoryFields()
+    def groupColumns(self):
+        return self.context.getGroupFields()
 
 
 class CombinedResultSet(ResultSet):