lims: allow to sort by function fields in results report

lims/locale/es.po

@@ -4927,6 +4927,10 @@ msgctxt "field:lims.results_report.version,number:"
 msgid "Number"
 msgstr "Número"
 
+msgctxt "field:lims.results_report.version,party:"
+msgid "Party"
+msgstr "Entidad"
+
 msgctxt "field:lims.results_report.version,report_type:"
 msgid "Report type"
 msgstr "Tipo de informe"

lims/results_report.py

@@ -191,6 +191,22 @@ class ResultsReport(ModelSQL, ModelView):
         nested = clause[0].lstrip(name)
         return [('entry.' + name + nested,) + tuple(clause[1:])]
 
+    def _order_entry_field(name):
+        def order_field(tables):
+            Entry = Pool().get('lims.entry')
+            field = Entry._fields[name]
+            table, _ = tables[None]
+            entry_tables = tables.get('entry')
+            if entry_tables is None:
+                entry = Entry.__table__()
+                entry_tables = {
+                    None: (entry, entry.id == table.entry),
+                    }
+                tables['entry'] = entry_tables
+            return field.convert_order(name, entry_tables, Entry)
+        return staticmethod(order_field)
+    order_invoice_party = _order_entry_field('invoice_party')
+
     @classmethod
     def get_single_sending_report_ready(cls, reports, name):
         cursor = Transaction().connection.cursor()
@@ -452,6 +468,8 @@ class ResultsReportVersion(ModelSQL, ModelView):
         'report_version', 'Detail lines', readonly=True)
     report_type = fields.Function(fields.Char('Report type'),
         'get_report_type')
+    party = fields.Function(fields.Many2One('party.party', 'Party'),
+       'get_report_field', searcher='search_report_field')
 
     @classmethod
     def __setup__(cls):
@@ -494,6 +512,46 @@ class ResultsReportVersion(ModelSQL, ModelView):
                 values['laboratory'])
         return super().create(vlist)
 
+    @classmethod
+    def get_report_field(cls, versions, names):
+        result = {}
+        for name in names:
+            result[name] = {}
+            if cls._fields[name]._type == 'many2one':
+                for v in versions:
+                    field = getattr(v.results_report, name, None)
+                    result[name][v.id] = field.id if field else None
+            elif cls._fields[name]._type == 'boolean':
+                for v in versions:
+                    field = getattr(v.results_report, name, False)
+                    result[name][v.id] = field
+            else:
+                for v in versions:
+                    field = getattr(v.results_report, name, None)
+                    result[name][v.id] = field
+        return result
+
+    @classmethod
+    def search_report_field(cls, name, clause):
+        return [('results_report.' + name,) + tuple(clause[1:])]
+
+    def _order_report_field(name):
+        def order_field(tables):
+            ResultsReport = Pool().get('lims.results_report')
+            field = ResultsReport._fields[name]
+            table, _ = tables[None]
+            report_tables = tables.get('results_report')
+            if report_tables is None:
+                results_report = ResultsReport.__table__()
+                report_tables = {
+                    None: (results_report,
+                        results_report.id == table.results_report),
+                    }
+                tables['results_report'] = report_tables
+            return field.convert_order(name, report_tables, ResultsReport)
+        return staticmethod(order_field)
+    order_party = _order_report_field('party')
+
 
 class ResultsReportVersionDetail(Workflow, ModelSQL, ModelView):
     'Results Report Version Detail'
@@ -1167,15 +1225,41 @@ class ResultsReportVersionDetail(Workflow, ModelSQL, ModelView):
         result = {}
         for name in names:
             result[name] = {}
-            for d in details:
-                field = getattr(d.report_version, name, None)
-                result[name][d.id] = field.id if field else None
+            if cls._fields[name]._type == 'many2one':
+                for d in details:
+                    field = getattr(d.report_version, name, None)
+                    result[name][d.id] = field.id if field else None
+            elif cls._fields[name]._type == 'boolean':
+                for d in details:
+                    field = getattr(d.report_version, name, False)
+                    result[name][d.id] = field
+            else:
+                for d in details:
+                    field = getattr(d.report_version, name, None)
+                    result[name][d.id] = field
         return result
 
     @classmethod
     def search_version_field(cls, name, clause):
         return [('report_version.' + name,) + tuple(clause[1:])]
 
+    def _order_version_field(name):
+        def order_field(tables):
+            ResultsVersion = Pool().get('lims.results_report.version')
+            field = ResultsVersion._fields[name]
+            table, _ = tables[None]
+            version_tables = tables.get('report_version')
+            if version_tables is None:
+                report_version = ResultsVersion.__table__()
+                version_tables = {
+                    None: (report_version,
+                        report_version.id == table.report_version),
+                    }
+                tables['report_version'] = version_tables
+            return field.convert_order(name, version_tables, ResultsVersion)
+        return staticmethod(order_field)
+    order_laboratory = _order_version_field('laboratory')
+
     @classmethod
     def get_report_field(cls, details, names):
         result = {}
@@ -1202,6 +1286,25 @@ class ResultsReportVersionDetail(Workflow, ModelSQL, ModelView):
     def search_report_field(cls, name, clause):
         return [('report_version.results_report.' + name,) + tuple(clause[1:])]
 
+    def _order_report_field(name):
+        def order_field(tables):
+            pool = Pool()
+            ResultsReport = pool.get('lims.results_report')
+            ResultsVersion = pool.get('lims.results_report.version')
+            field = ResultsReport._fields[name]
+            table, _ = tables[None]
+            version_tables = tables.get('report_version')
+            if version_tables is None:
+                report_version = ResultsVersion.__table__()
+                version_tables = {
+                    None: (report_version,
+                        report_version.id == table.report_version),
+                    }
+                tables['report_version'] = version_tables
+            return field.convert_order(name, version_tables, ResultsVersion)
+        return staticmethod(order_field)
+    order_party = _order_report_field('party')
+
     @classmethod
     def get_entry_field(cls, details, names):
         result = {}
@@ -1214,6 +1317,7 @@ class ResultsReportVersionDetail(Workflow, ModelSQL, ModelView):
                             name, None) or None)
                     result[name][d.id] = field.id if field else None
             elif cls._fields[name]._type == 'boolean':
+                for d in details:
                     field = (d.report_version.results_report.entry and
                         getattr(d.report_version.results_report.entry,
                             name, False) or False)