'text': fields.text(),
}
+ # `base` module does not contains any model that implement the `_group_by_full` functionality
+ # test this feature here...
+
+ def _gbf_m2o(self, cr, uid, ids, domain, read_group_order, access_rights_uid, context):
+ Sub = self.pool['test_converter.test_model.sub']
+ all_ids = Sub._search(cr, uid, [], access_rights_uid=access_rights_uid, context=context)
+ result = Sub.name_get(cr, access_rights_uid or uid, all_ids, context=context)
+ folds = {i: i not in ids for i, _ in result}
+ return result, folds
+
+ _group_by_full = {
+ 'many2one': _gbf_m2o,
+ }
+
+
class test_model_sub(orm.Model):
_name = 'test_converter.test_model.sub'
--- /dev/null
+# -*- coding: utf-8 -*-
+from openerp.tests import common
+
+class TestGBF(common.TransactionCase):
+
+ def test_group_by_full(self):
+
+ Subs = self.registry('test_converter.test_model.sub')
+ TM = self.registry('test_converter.test_model')
+
+ # remove all existing subs (no need to panic, it will be rollbacked...)
+ all_subs = Subs.search(self.cr, self.uid, [])
+ if all_subs:
+ Subs.unlink(self.cr, self.uid, all_subs)
+
+ subs_ids = [Subs.create(self.cr, self.uid, {'name': 'sub%d' % i}) for i in range(5)]
+ tm_ids = [TM.create(self.cr, self.uid, {'many2one': subs_ids[i]}) for i in range(3)]
+
+ domain = [('id', 'in', tuple(tm_ids))]
+
+ rg = TM.read_group(self.cr, self.uid, domain, fields=['many2one'], groupby=['many2one'])
+
+ self.assertEqual(len(rg), len(subs_ids))
+ rg_subs = sorted(g['many2one'][0] for g in rg)
+ self.assertListEqual(rg_subs, sorted(subs_ids))
pass
- def _read_group_fill_results(self, cr, uid, domain, groupby, remaining_groupbys, aggregated_fields,
+ def _read_group_fill_results(self, cr, uid, domain, groupby, remaining_groupbys,
+ aggregated_fields, count_field,
read_group_result, read_group_order=None, context=None):
"""Helper method for filling in empty groups for all possible values of
the field being grouped by"""
result = []
known_values = {}
- if len(groupby_list) < 2 and context.get('group_by_no_leaf'):
- count_attr = '_'
- else:
- count_attr = groupby
- count_attr += '_count'
-
def append_left(left_side):
grouped_value = left_side[groupby] and left_side[groupby][0]
if not grouped_value in known_values:
result.append(left_side)
known_values[grouped_value] = left_side
else:
- known_values[grouped_value].update({count_attr: left_side[count_attr]})
+ known_values[grouped_value].update({count_field: left_side[count_field]})
def append_right(right_side):
grouped_value = right_side[0]
if not grouped_value in known_values:
count_field = groupby_fields[0] if len(groupby_fields) >= 1 else '_'
else:
count_field = '_'
+ count_field += '_count'
prefix_terms = lambda prefix, terms: (prefix + " " + ",".join(terms)) if terms else ''
prefix_term = lambda prefix, term: ('%s %s' % (prefix, term)) if term else ''
query = """
- SELECT min(%(table)s.id) AS id, count(%(table)s.id) AS %(count_field)s_count %(extra_fields)s
+ SELECT min(%(table)s.id) AS id, count(%(table)s.id) AS %(count_field)s %(extra_fields)s
FROM %(from)s
%(where)s
%(groupby)s
# method _read_group_fill_results need to be completely reimplemented
# in a sane way
result = self._read_group_fill_results(cr, uid, domain, groupby_fields[0], groupby[len(annotated_groupbys):],
- aggregated_fields, result, read_group_order=order,
+ aggregated_fields, count_field, result, read_group_order=order,
context=context)
return result