From 6412575f4bebf9ac73a0c550ac408d8488feb140 Mon Sep 17 00:00:00 2001
From: std-odoo <std@odoo.com>
Date: Wed, 19 Apr 2023 08:16:16 +0200
Subject: [PATCH 1/6] [IMP] base: allow to use `default_` context key for
 properties

Purpose
=======
Allow to use `default_properties.xxxxx` as a context key, to set the
default value on a property. We need that because when we group by
a property in a Kanban view, we can create new record in a given
column, and this process will set this context key.

Task-3032464

Part-of: odoo/odoo#103510
---
 .../test_new_api/tests/test_properties.py     | 35 +++++++++++++++++++
 odoo/fields.py                                |  7 +++-
 2 files changed, 41 insertions(+), 1 deletion(-)

diff --git a/odoo/addons/test_new_api/tests/test_properties.py b/odoo/addons/test_new_api/tests/test_properties.py
index 5bb2f5a2578..e78b6220a10 100644
--- a/odoo/addons/test_new_api/tests/test_properties.py
+++ b/odoo/addons/test_new_api/tests/test_properties.py
@@ -604,6 +604,41 @@ class PropertiesCase(TestPropertiesMixin):
         })
         self.assertEqual(self._get_sql_properties(record), {'my_char': 'my char', 'test': self.partner_2.id})
 
+        # use the context to set the default value, the default key in the definition is ignored
+        # (e.g. when you create a new record in a Kanban view grouped by a property)
+        del property_definition[0]['value']
+        self.discussion_1.attributes_definition = property_definition
+        partner = self.env['test_new_api.partner'].create({'name': 'Test Default'})
+        message = self.env['test_new_api.message'] \
+            .with_context({'default_attributes.my_many2one': partner.id}) \
+            .create({
+                'name': 'Test Message',
+                'author': self.user.id,
+                'discussion': self.discussion_1.id,
+                'attributes': property_definition,
+            })
+
+        sql_values = self._get_sql_properties(message)
+        self.assertEqual(sql_values, {'my_many2one': partner.id})
+        properties = message.read(['attributes'])[0]['attributes']
+        self.assertEqual(properties[0]['value'], (partner.id, partner.display_name))
+
+        # "None" is a valid default value
+        del property_definition[0]['value']
+        message = self.env['test_new_api.message'] \
+            .with_context({'default_attributes.my_many2one': None}) \
+            .create({
+                'name': 'Test Message',
+                'author': self.user.id,
+                'discussion': self.discussion_1.id,
+                'attributes': property_definition,
+            })
+
+        sql_values = self._get_sql_properties(message)
+        self.assertEqual(sql_values, {'my_many2one': False})
+        properties = message.read(['attributes'])[0]['attributes']
+        self.assertEqual(properties[0]['value'], False)
+
     def test_properties_field_read(self):
         """Test the behavior of the read method.
 
diff --git a/odoo/fields.py b/odoo/fields.py
index b0ede449b2f..b38dc999304 100644
--- a/odoo/fields.py
+++ b/odoo/fields.py
@@ -3545,7 +3545,12 @@ class Properties(Field):
 
         for properties_value in properties_list_values:
             if properties_value.get('value') is None:
-                default = properties_value.get('default') or False
+                property_name = properties_value.get('name')
+                context_key = f"default_{self.name}.{property_name}"
+                if property_name and context_key in env.context:
+                    default = env.context[context_key]
+                else:
+                    default = properties_value.get('default') or False
                 properties_value['value'] = default
 
         return properties_list_values

From 6c566c2814ff803ad75dc35ed5290cf9e213ce05 Mon Sep 17 00:00:00 2001
From: std-odoo <std@odoo.com>
Date: Wed, 19 Apr 2023 08:48:05 +0200
Subject: [PATCH 2/6] [IMP] base: properties, better name verification

Purpose
=======
Currently, it is possible to use some bad characters in a property name
by writing directly on the parent (not via the child).

It's possible only with RPC call and it wasn't an issue because we
recheck the name anyway before using it in SQL query (but it should be
cleaned).

We also restrict the maximum length (there's nor reason to use
huge property names).

Task-3032464

Part-of: odoo/odoo#103510
---
 .../test_new_api/tests/test_properties.py     | 28 +++++++++++++++++++
 odoo/fields.py                                |  3 +-
 odoo/models.py                                |  4 +--
 3 files changed, 32 insertions(+), 3 deletions(-)

diff --git a/odoo/addons/test_new_api/tests/test_properties.py b/odoo/addons/test_new_api/tests/test_properties.py
index e78b6220a10..937ad908234 100644
--- a/odoo/addons/test_new_api/tests/test_properties.py
+++ b/odoo/addons/test_new_api/tests/test_properties.py
@@ -186,6 +186,34 @@ class PropertiesCase(TestPropertiesMixin):
             'default': 'blue',
         }])
 
+    def test_properties_field_injection(self):
+        for c in '!#"\'- |+/\\':
+            with self.assertRaises(ValueError):
+                self.message_1.attributes = [{
+                    'name': f'discussion_color_code{c}',
+                    'type': 'char',
+                    'definition_changed': True
+                }]
+
+            with self.assertRaises(ValueError):
+                self.discussion_1.attributes_definition = [{
+                    'name': f'discussion_color_code{c}',
+                    'type': 'char',
+                }]
+
+        with self.assertRaises(ValueError):
+            self.message_1.attributes = [{
+                'name': 'a' * 513,
+                'type': 'char',
+                'definition_changed': True
+            }]
+
+        with self.assertRaises(ValueError):
+            self.discussion_1.attributes_definition = [{
+                'name': 'a' * 513,
+                'type': 'char',
+            }]
+
     @mute_logger('odoo.fields')
     def test_properties_field_write_batch(self):
         """Test the behavior of the write called in batch.
diff --git a/odoo/fields.py b/odoo/fields.py
index b38dc999304..e6bb321c007 100644
--- a/odoo/fields.py
+++ b/odoo/fields.py
@@ -3477,7 +3477,6 @@ class Properties(Field):
             ]
             for definition in value:
                 definition.pop('definition_changed', None)
-                check_property_field_value_name(definition.get('name', ''))
 
             # update the properties definition on the container
             container = records[self.definition_record]
@@ -3946,6 +3945,8 @@ class PropertiesDefinition(Field):
                     ', '.join(invalid_keys),
                 )
 
+            check_property_field_value_name(property_definition['name'])
+
             required_keys = set(cls.REQUIRED_KEYS) - property_definition_keys
             if required_keys:
                 raise ValueError(
diff --git a/odoo/models.py b/odoo/models.py
index 2dfb8a9dfc5..4559f3040b9 100644
--- a/odoo/models.py
+++ b/odoo/models.py
@@ -146,8 +146,8 @@ def check_method_name(name):
 
 
 def check_property_field_value_name(property_name):
-    if not regex_alphanumeric.match(property_name):
-        raise ValueError(_("Wrong property field value name %r.", property_name))
+    if not regex_alphanumeric.match(property_name) or len(property_name) > 512:
+        raise ValueError(f"Wrong property field value name {property_name!r}.")
 
 
 def fix_import_export_id_paths(fieldname):

From 88f4c4dd36fb0d74e8adf1ea2a9572c495dcce8c Mon Sep 17 00:00:00 2001
From: std-odoo <std@odoo.com>
Date: Wed, 19 Apr 2023 08:35:35 +0200
Subject: [PATCH 3/6] [IMP] base: properties, do not allow to select transient
 models

Purpose
=======
Do not allow to select transient models in relational properties.

Task-3032464

Part-of: odoo/odoo#103510
---
 addons/web/models/ir_model.py                 | 16 ++++++----
 addons/web/tests/test_ir_model.py             |  9 ++++++
 .../test_new_api/models/test_new_api.py       |  5 ++++
 .../test_new_api/security/ir.model.access.csv |  1 +
 .../test_new_api/tests/test_properties.py     | 30 +++++++++++++++++++
 odoo/fields.py                                |  2 +-
 6 files changed, 57 insertions(+), 6 deletions(-)

diff --git a/addons/web/models/ir_model.py b/addons/web/models/ir_model.py
index ade00f6ee89..44ce0e9c074 100644
--- a/addons/web/models/ir_model.py
+++ b/addons/web/models/ir_model.py
@@ -19,7 +19,7 @@ class IrModel(models.Model):
         accessible_models = []
         not_accessible_models = []
         for model in models:
-            if self._check_model_access(model):
+            if self._is_valid_for_model_selector(model):
                 accessible_models.append(model)
             else:
                 not_accessible_models.append({"display_name": model, "model": model})
@@ -34,9 +34,15 @@ class IrModel(models.Model):
         } for model in records]
 
     @api.model
-    def _check_model_access(self, model):
-        return (self.env.user._is_internal() and model in self.env
-                and self.env[model].check_access_rights("read", raise_exception=False))
+    def _is_valid_for_model_selector(self, model):
+        model = self.env.get(model)
+        return (
+            self.env.user._is_internal()
+            and model is not None
+            and model.check_access_rights("read", raise_exception=False)
+            and not model._transient
+            and not model._abstract
+        )
 
     @api.model
     def get_available_models(self):
@@ -44,5 +50,5 @@ class IrModel(models.Model):
         Return the list of models the current user has access to, with their
         corresponding display name.
         """
-        accessible_models = [model for model in self.pool.keys() if self._check_model_access(model)]
+        accessible_models = [model for model in self.pool if self._is_valid_for_model_selector(model)]
         return self._display_name_for(accessible_models)
diff --git a/addons/web/tests/test_ir_model.py b/addons/web/tests/test_ir_model.py
index 8ba412761cb..3b718bbd3e9 100644
--- a/addons/web/tests/test_ir_model.py
+++ b/addons/web/tests/test_ir_model.py
@@ -63,3 +63,12 @@ class IrModelAccessTest(TransactionCase):
         # non existent model comes after existent model
         result = self.env['ir.model'].display_name_for(["res.company", "unexistent"])
         self.assertEqual(result, [{"display_name": "Companies", "model": "res.company"}, {"display_name": "unexistent", "model": "unexistent"}])
+        # transient models
+        result = self.env['ir.model'].display_name_for(["res.company", "base.language.export"])
+        self.assertEqual(result, [{"display_name": "Companies", "model": "res.company"}, {"display_name": "base.language.export", "model": "base.language.export"}])
+
+        # do not return results for transient models
+        result = self.env['ir.model'].get_available_models()
+        result = {values["model"] for values in result}
+        self.assertIn("res.company", result)
+        self.assertNotIn("base.language.export", result)
diff --git a/odoo/addons/test_new_api/models/test_new_api.py b/odoo/addons/test_new_api/models/test_new_api.py
index 17c875fa9bf..bd3aa6d176a 100644
--- a/odoo/addons/test_new_api/models/test_new_api.py
+++ b/odoo/addons/test_new_api/models/test_new_api.py
@@ -962,6 +962,11 @@ class RequiredM2OTransient(models.TransientModel):
     bar = fields.Many2one('res.country', required=True)
 
 
+class TestTransient(models.TransientModel):
+    _name = 'test_new_api.transient_model'
+    _description = 'Transient Model'
+
+
 class Attachment(models.Model):
     _name = 'test_new_api.attachment'
     _description = 'Attachment'
diff --git a/odoo/addons/test_new_api/security/ir.model.access.csv b/odoo/addons/test_new_api/security/ir.model.access.csv
index 1c25a03c3d1..8207897d07e 100644
--- a/odoo/addons/test_new_api/security/ir.model.access.csv
+++ b/odoo/addons/test_new_api/security/ir.model.access.csv
@@ -114,3 +114,4 @@ access_test_new_api_unsearchable_o2m_employee,access_test_new_api_unsearchable_o
 access_test_new_api_any_parent,access_test_new_api_any_parent,model_test_new_api_any_parent,base.group_user,1,0,0,0
 access_test_new_api_any_child,access_test_new_api_any_child,model_test_new_api_any_child,base.group_user,1,0,0,0
 access_test_new_api_any_tag,access_test_new_api_any_tag,model_test_new_api_any_tag,base.group_user,1,0,0,0
+access_test_new_api_transient_model,access_test_new_api_transient_model,model_test_new_api_transient_model,base.group_user,1,1,1,1
diff --git a/odoo/addons/test_new_api/tests/test_properties.py b/odoo/addons/test_new_api/tests/test_properties.py
index 937ad908234..f3529c0c765 100644
--- a/odoo/addons/test_new_api/tests/test_properties.py
+++ b/odoo/addons/test_new_api/tests/test_properties.py
@@ -740,6 +740,21 @@ class PropertiesCase(TestPropertiesMixin):
         self.assertEqual(properties[1]['value'], (self.partner_2.id, self.partner_2.display_name))
         self.assertEqual(properties[1]['comodel'], 'test_new_api.partner')
 
+        # should not be able to set a transient model
+        with self.assertRaises(ValueError):
+            self.message_2.attributes = [{
+                "name": "moderator_partner_id",
+                "type": "many2one",
+                "comodel": "test_new_api.transient_model",
+                "definition_changed": True,
+            }]
+        with self.assertRaises(ValueError):
+            self.discussion_1.attributes_definition = [{
+                "name": "moderator_partner_id",
+                "type": "many2one",
+                "comodel": "test_new_api.transient_model",
+            }]
+
     @mute_logger('odoo.models.unlink', 'odoo.fields')
     def test_properties_field_many2one_unlink(self):
         """Test the case where we unlink the many2one record."""
@@ -1232,6 +1247,21 @@ class PropertiesCase(TestPropertiesMixin):
                 'value': [(partners[9].id, partners[9].display_name)],
             }])
 
+        # should not be able to set a transient model
+        with self.assertRaises(ValueError):
+            self.message_2.attributes = [{
+                "name": "partner_ids",
+                "type": "many2many",
+                "comodel": "test_new_api.transient_model",
+                "definition_changed": True,
+            }]
+        with self.assertRaises(ValueError):
+            self.discussion_1.attributes_definition = [{
+                "name": "partner_ids",
+                "type": "many2many",
+                "comodel": "test_new_api.transient_model",
+            }]
+
     @users('test')
     @mute_logger('odoo.addons.base.models.ir_rule', 'odoo.fields')
     def test_properties_field_many2many_filtering(self):
diff --git a/odoo/fields.py b/odoo/fields.py
index e6bb321c007..1d95386fe10 100644
--- a/odoo/fields.py
+++ b/odoo/fields.py
@@ -3964,7 +3964,7 @@ class PropertiesDefinition(Field):
                 raise ValueError(f'Wrong property type {property_type!r}.')
 
             model = property_definition.get('comodel')
-            if model and model not in env:
+            if model and (model not in env or env[model].is_transient() or env[model]._abstract):
                 raise ValueError(f'Invalid model name {model!r}')
 
             property_selection = property_definition.get('selection')

From 15353f06d7b332197d3c5ceeab6bf48f47d2c60e Mon Sep 17 00:00:00 2001
From: std-odoo <std@odoo.com>
Date: Thu, 20 Apr 2023 11:44:26 +0200
Subject: [PATCH 4/6] [IMP] base, web: allow to group by properties

Purpose
=======
Allow to group records by their property values,
like we can do with normal fields.

Technical
=========
Because there's no foreign key, when we group by a relational property
we need to check the existence of the ids in the query (and same for
selection and tags, because we might have value of a deleted
option / tag in database).

Task-3032464

Part-of: odoo/odoo#103510
---
 addons/web/models/models.py                   |  21 +-
 addons/web/static/src/core/field_service.js   |  13 +-
 .../src/model/relational_model/record.js      |  18 +-
 .../relational_model/relational_model.js      |  36 +
 .../src/model/relational_model/utils.js       |   2 +-
 .../custom_group_by_item.xml                  |   1 +
 .../properties_group_by_item.js               |  71 ++
 .../properties_group_by_item.xml              |  40 +
 .../search/search_bar_menu/search_bar_menu.js |   7 +-
 .../search_bar_menu/search_bar_menu.xml       |   5 +-
 addons/web/static/src/search/search_model.js  | 115 ++-
 addons/web/static/src/search/utils/misc.js    |   1 +
 .../src/views/pivot/pivot_group_by_menu.js    |   8 +-
 .../src/views/pivot/pivot_group_by_menu.xml   |   5 +-
 .../static/tests/core/field_service_tests.js  |   1 +
 .../tests/search/search_bar_menu_tests.js     | 136 +++
 .../static/tests/search/search_bar_tests.js   |   3 +-
 .../test_new_api/tests/test_properties.py     | 880 +++++++++++++++++-
 odoo/models.py                                | 346 ++++++-
 odoo/tools/query.py                           |   5 +
 20 files changed, 1628 insertions(+), 86 deletions(-)
 create mode 100644 addons/web/static/src/search/properties_group_by_item/properties_group_by_item.js
 create mode 100644 addons/web/static/src/search/properties_group_by_item/properties_group_by_item.xml

diff --git a/addons/web/models/models.py b/addons/web/models/models.py
index 993da2a539d..61b7b7265ac 100644
--- a/addons/web/models/models.py
+++ b/addons/web/models/models.py
@@ -275,8 +275,9 @@ class Base(models.AbstractModel):
         :return a dictionnary mapping group_by values to dictionnaries mapping
                 progress bar field values to the related number of records
         """
-        group_by_fname = group_by.partition(':')[0]
-        field_type = self._fields[group_by_fname].type
+        group_by_fullname = group_by.partition(':')[0]
+        group_by_fieldname = group_by_fullname.split(".")[0]  # split on "." in case we group on a property
+        field_type = self._fields[group_by_fieldname].type
         if field_type == 'selection':
             selection_labels = dict(self.fields_get()[group_by]['selection'])
 
@@ -311,14 +312,22 @@ class Base(models.AbstractModel):
 
         # Workaround to match read_group's infrastructure
         # TO DO in master: harmonize this function and readgroup to allow factorization
-        group_by_name = group_by.partition(':')[0]
+        group_by_fullname = group_by.partition(':')[0]
+        group_by_fieldname = group_by_fullname.split(".")[0]  # split on "." in case we group on a property
         group_by_modifier = group_by.partition(':')[2] or 'month'
 
-        records_values = self.search_read(domain or [], [progress_bar['field'], group_by_name])
-        field_type = self._fields[group_by_name].type
+        records_values = self.search_read(domain or [], [progress_bar['field'], group_by_fieldname])
+        field_type = self._fields[group_by_fieldname].type
 
         for record_values in records_values:
-            group_by_value = record_values.pop(group_by_name)
+            group_by_value = record_values.pop(group_by_fieldname)
+            property_name = group_by_fullname.partition('.')[2]
+            if field_type == "properties" and group_by_value:
+                group_by_value = next(
+                    (definition['value'] for definition in group_by_value
+                     if definition['name'] == property_name),
+                    False,
+                )
 
             # Again, imitating what _read_group_format_result and _read_group_prepare_data do
             if group_by_value and field_type in ['date', 'datetime']:
diff --git a/addons/web/static/src/core/field_service.js b/addons/web/static/src/core/field_service.js
index 4c405efa855..99555dd17a2 100644
--- a/addons/web/static/src/core/field_service.js
+++ b/addons/web/static/src/core/field_service.js
@@ -55,19 +55,22 @@ export const fieldService = {
 
             domain = Domain.and([[[definitionRecordField, "!=", false]], domain]).toList();
 
-            const records = await orm.searchRead(definitionRecordModel, domain, [
-                "display_name",
-                definitionRecordField,
-            ]);
+            const result = await orm.webSearchRead(definitionRecordModel, domain, {
+                specification: {
+                    display_name: {},
+                    [definitionRecordField]: {},
+                },
+            });
 
             const definitions = {};
-            for (const record of records) {
+            for (const record of result.records) {
                 for (const definition of record[definitionRecordField]) {
                     definitions[definition.name] = {
                         is_property: true,
                         // for now, all properties are searchable but their definitions don't contain that info
                         searchable: true,
                         // differentiate definitions with same name but on different parent
+                        record_id: record.id,
                         record_name: record.display_name,
                         ...definition,
                     };
diff --git a/addons/web/static/src/model/relational_model/record.js b/addons/web/static/src/model/relational_model/record.js
index 52afbb48d70..c9b76a69c8a 100644
--- a/addons/web/static/src/model/relational_model/record.js
+++ b/addons/web/static/src/model/relational_model/record.js
@@ -981,10 +981,22 @@ export class Record extends DataPoint {
         for (const [fieldName, value] of Object.entries(changes)) {
             const field = this.fields[fieldName];
             if (field && field.relatedPropertyField) {
-                const propertyFieldName = field.relatedPropertyField.fieldName;
-                changes[propertyFieldName] = this.data[propertyFieldName].map((property) =>
-                    property.name === field.propertyName ? { ...property, value } : property
+                const [propertyFieldName, propertyName] = field.name.split(".");
+                const propertiesData = this.data[propertyFieldName] || [];
+                if (!propertiesData.find((property) => property.name === propertyName)) {
+                    // try to change the value of a properties that has a different parent
+                    this.model.notification.add(
+                        _t(
+                            "This record belongs to a different parent so you can not change this property."
+                        ),
+                        { type: "warning" }
+                    );
+                    return;
+                }
+                changes[propertyFieldName] = propertiesData.map((property) =>
+                    property.name === propertyName ? { ...property, value } : property
                 );
+                delete changes[field.name];
             }
         }
         const onChangeFields = Object.keys(changes).filter(
diff --git a/addons/web/static/src/model/relational_model/relational_model.js b/addons/web/static/src/model/relational_model/relational_model.js
index ed9468725ae..1b1af02b6dc 100644
--- a/addons/web/static/src/model/relational_model/relational_model.js
+++ b/addons/web/static/src/model/relational_model/relational_model.js
@@ -22,6 +22,7 @@ import {
     getBasicEvalContext,
     getFieldsSpec,
     isRelational,
+    makeActiveField,
 } from "./utils";
 
 /**
@@ -186,6 +187,30 @@ export class RelationalModel extends Model {
     // Protected
     // -------------------------------------------------------------------------
 
+    /**
+     * If we group by default based on a property, the property might not be loaded in `fields`.
+     */
+    async _getPropertyDefinition(config, propertyFullName) {
+        // dynamically load the property and add the definition in the fields attribute
+        const result = await this.orm.call(
+            config.resModel,
+            "get_property_definition",
+            [propertyFullName],
+            { context: config.context }
+        );
+        if (!result) {
+            // the property might have been removed
+            config.groupBy = null;
+        } else {
+            result.propertyName = result.name;
+            result.name = propertyFullName; // "xxxxx" -> "property.xxxxx"
+            // needed for _applyChanges
+            result.relatedPropertyField = { fieldName: propertyFullName.split(".")[0] };
+            result.relation = result.comodel; // match name on field
+            config.fields[propertyFullName] = result;
+        }
+    }
+
     _askChanges() {
         const proms = [];
         this.bus.trigger("NEED_LOCAL_CHANGES", { proms });
@@ -330,6 +355,17 @@ export class RelationalModel extends Model {
         }
         config.groups = config.groups || {};
         const firstGroupByName = config.groupBy[0].split(":")[0];
+        if (firstGroupByName.includes(".")) {
+            if (!config.fields[firstGroupByName]) {
+                await this._getPropertyDefinition(config, firstGroupByName);
+            }
+            const propertiesFieldName = firstGroupByName.split(".")[0];
+            if (!config.activeFields[propertiesFieldName]) {
+                // add the properties field so we load its data when reading the records
+                // so when we drag and drop we don't need to fetch the value of the record
+                config.activeFields[propertiesFieldName] = makeActiveField();
+            }
+        }
         const orderBy = config.orderBy.filter(
             (o) =>
                 o.name === firstGroupByName ||
diff --git a/addons/web/static/src/model/relational_model/utils.js b/addons/web/static/src/model/relational_model/utils.js
index 6e847445d8a..91f00ed6737 100644
--- a/addons/web/static/src/model/relational_model/utils.js
+++ b/addons/web/static/src/model/relational_model/utils.js
@@ -521,7 +521,7 @@ function getDisplayNameFromGroupData(field, rawValue) {
     if (field.type === "selection") {
         return Object.fromEntries(field.selection)[rawValue];
     }
-    if (["many2one", "many2many"].includes(field.type)) {
+    if (["many2one", "many2many", "tags"].includes(field.type)) {
         return rawValue ? rawValue[1] : false;
     }
     return rawValue;
diff --git a/addons/web/static/src/search/custom_group_by_item/custom_group_by_item.xml b/addons/web/static/src/search/custom_group_by_item/custom_group_by_item.xml
index 51a41755b56..313b7d74374 100644
--- a/addons/web/static/src/search/custom_group_by_item/custom_group_by_item.xml
+++ b/addons/web/static/src/search/custom_group_by_item/custom_group_by_item.xml
@@ -6,6 +6,7 @@
                 <select class="pe-3 text-truncate o_input" t-model="state.fieldName">
                     <option t-foreach="props.fields" t-as="field" t-key="field.name"
                     t-att-value="field.name"
+                    t-if="field.type !== 'properties' and !field.isProperty"
                     t-esc="field.string"
                     />
                 </select>
diff --git a/addons/web/static/src/search/properties_group_by_item/properties_group_by_item.js b/addons/web/static/src/search/properties_group_by_item/properties_group_by_item.js
new file mode 100644
index 00000000000..6b0fcc20f96
--- /dev/null
+++ b/addons/web/static/src/search/properties_group_by_item/properties_group_by_item.js
@@ -0,0 +1,71 @@
+/** @odoo-module **/
+
+import { AccordionItem, ACCORDION } from "@web/core/dropdown/accordion_item";
+import { SearchDropdownItem } from "@web/search/search_dropdown_item/search_dropdown_item";
+import { Component, useState, useChildSubEnv } from "@odoo/owl";
+
+export class PropertiesGroupByItem extends Component {
+    static template = "web.PropertiesGroupByItem";
+    static components = { AccordionItem, SearchDropdownItem };
+    static props = {
+        item: Object,
+        onGroup: Function,
+    };
+
+    setup() {
+        this.state = useState({ groupByItems: [] });
+        useChildSubEnv({
+            [ACCORDION]: {
+                accordionStateChanged: this.beforeOpen.bind(this),
+            },
+        });
+    }
+
+    /**
+     * The properties field is considered as active if one of its property is active.
+     */
+    get isActive() {
+        return this.state.groupByItems.some((item) => item.isActive);
+    }
+
+    /**
+     * True if all group items come from the same definition record.
+     */
+    get isSingleParent() {
+        const uniqueNames = new Set(this.state.groupByItems.map((item) => item.definitionRecordId));
+        return uniqueNames.size < 2;
+    }
+
+    /**
+     * Dynamically load the definition, only when needed (if we open the dropdown).
+     */
+    async beforeOpen() {
+        if (this.definitionLoaded) {
+            return;
+        }
+        this.definitionLoaded = true;
+
+        await this.env.searchModel.fillSearchViewItemsProperty();
+        this._updateGroupByItems();
+    }
+
+    /**
+     * Callback to group records per one property.
+     */
+    onGroup(ids) {
+        this.props.onGroup(ids);
+        this._updateGroupByItems(); // isActive state might have changed
+    }
+
+    /**
+     * Update the component state to sync it with the search model group item.
+     */
+    _updateGroupByItems() {
+        this.state.groupByItems = this.env.searchModel.getSearchItems(
+            (searchItem) =>
+                ["groupBy", "dateGroupBy"].includes(searchItem.type) &&
+                searchItem.isProperty &&
+                searchItem.propertyFieldName === this.props.item.fieldName
+        );
+    }
+}
diff --git a/addons/web/static/src/search/properties_group_by_item/properties_group_by_item.xml b/addons/web/static/src/search/properties_group_by_item/properties_group_by_item.xml
new file mode 100644
index 00000000000..abb41b33f2a
--- /dev/null
+++ b/addons/web/static/src/search/properties_group_by_item/properties_group_by_item.xml
@@ -0,0 +1,40 @@
+<templates xml:space="preserve">
+    <t t-name="web.PropertiesGroupByItem" owl="1">
+        <AccordionItem
+            class="'o_add_custom_group_menu text-truncate'"
+            description="props.item.description"
+            selected="isActive">
+            <t t-set="items" t-value="state.groupByItems"/>
+            <t t-if="items and items.length">
+                <t t-foreach="items" t-as="item" t-key="item.name">
+                    <t t-set="description" t-value="isSingleParent ? item.description : `${item.description} (${item.definitionRecordName})`"/>
+                    <!-- Item with options (e.g. Date / Datetime with option "month / quarter / week") -->
+                    <AccordionItem t-if="item.options"
+                        description="description"
+                        selected="item.isActive">
+                        <t t-foreach="item.options" t-as="option" t-key="option.id">
+                            <t t-set="optionName" t-value="`${item.name}:${option.id}`"/>
+                            <SearchDropdownItem class="{ o_item_option: true, selected: option.isActive }"
+                                checked="option.isActive"
+                                parentClosingMode="'none'"
+                                t-esc="option.description"
+                                onSelected="() => this.onGroup({ itemId: item.id, optionId: option.id})"
+                            />
+                        </t>
+                    </AccordionItem>
+                    <!-- Standard items without option -->
+                    <SearchDropdownItem t-else=""
+                        class="{ o_menu_item: true, selected: item.isActive }"
+                        checked="item.isActive"
+                        parentClosingMode="'none'"
+                        t-esc="description"
+                        onSelected="() => this.onGroup({ itemId: item.id })"
+                    />
+                </t>
+            </t>
+            <SearchDropdownItem t-else="" checked="false" parentClosingMode="'none'" class="'fst-italic'">
+                No Properties
+            </SearchDropdownItem>
+        </AccordionItem>
+    </t>
+</templates>
diff --git a/addons/web/static/src/search/search_bar_menu/search_bar_menu.js b/addons/web/static/src/search/search_bar_menu/search_bar_menu.js
index 75587be4637..43314badd6c 100644
--- a/addons/web/static/src/search/search_bar_menu/search_bar_menu.js
+++ b/addons/web/static/src/search/search_bar_menu/search_bar_menu.js
@@ -4,6 +4,7 @@ import { Component } from "@odoo/owl";
 import { ConfirmationDialog } from "@web/core/confirmation_dialog/confirmation_dialog";
 import { DomainSelectorDialog } from "../../core/domain_selector_dialog/domain_selector_dialog";
 import { Dropdown } from "@web/core/dropdown/dropdown";
+import { PropertiesGroupByItem } from "@web/search/properties_group_by_item/properties_group_by_item";
 import { DropdownItem } from "@web/core/dropdown/dropdown_item";
 import { registry } from "@web/core/registry";
 import { sortBy } from "@web/core/utils/arrays";
@@ -25,6 +26,7 @@ export class SearchBarMenu extends Component {
         SearchDropdownItem,
         CustomGroupByItem,
         AccordionItem,
+        PropertiesGroupByItem,
     };
     static props = {
         slots: {
@@ -104,8 +106,9 @@ export class SearchBarMenu extends Component {
      * @returns {Object[]}
      */
     get groupByItems() {
-        return this.env.searchModel.getSearchItems((searchItem) =>
-            ["groupBy", "dateGroupBy"].includes(searchItem.type)
+        return this.env.searchModel.getSearchItems(
+            (searchItem) =>
+                ["groupBy", "dateGroupBy"].includes(searchItem.type) && !searchItem.isProperty
         );
     }
 
diff --git a/addons/web/static/src/search/search_bar_menu/search_bar_menu.xml b/addons/web/static/src/search/search_bar_menu/search_bar_menu.xml
index c44d2a66859..559f6b98c13 100644
--- a/addons/web/static/src/search/search_bar_menu/search_bar_menu.xml
+++ b/addons/web/static/src/search/search_bar_menu/search_bar_menu.xml
@@ -66,7 +66,10 @@
                         <t t-if="currentGroup !== null and currentGroup !== item.groupNumber">
                             <div class="dropdown-divider" role="separator"/>
                         </t>
-                        <t t-if="item.options">
+                        <t t-if="item.fieldType === 'properties'">
+                            <PropertiesGroupByItem item="item" onGroup.bind="onGroupBySelected"/>
+                        </t>
+                        <t t-elif="item.options">
                             <AccordionItem class="'text-truncate'" description="item.description" selected="item.isActive">
                                 <t t-set="subGroup" t-value="null"/>
                                 <t t-foreach="item.options" t-as="option" t-key="option.id">
diff --git a/addons/web/static/src/search/search_model.js b/addons/web/static/src/search/search_model.js
index 12f7e86bda1..3c5698ed8b7 100644
--- a/addons/web/static/src/search/search_model.js
+++ b/addons/web/static/src/search/search_model.js
@@ -3,7 +3,7 @@
 import { makeContext } from "@web/core/context";
 import { Domain } from "@web/core/domain";
 import { evaluateExpr } from "@web/core/py_js/py";
-import { sortBy } from "@web/core/utils/arrays";
+import { sortBy, groupBy } from "@web/core/utils/arrays";
 import { deepCopy } from "@web/core/utils/objects";
 import { SearchArchParser } from "./search_arch_parser";
 import {
@@ -170,6 +170,7 @@ export class SearchModel extends EventBus {
         // services
         const { field: fieldService, name: nameService, orm, user, view } = services;
         this.orm = orm;
+        this.fieldService = fieldService;
         this.userService = user;
         this.viewService = view;
 
@@ -996,13 +997,7 @@ export class SearchModel extends EventBus {
         }
         const field = this.searchViewFields[searchItem.fieldName];
         const definitionRecord = field.definition_record;
-        const definitionRecordModel = this.searchViewFields[definitionRecord].relation;
-        const definitionRecordField = field.definition_record_field;
-
-        const result = await this._fetchPropertiesDefinition(
-            definitionRecordModel,
-            definitionRecordField
-        );
+        const result = await this._fetchPropertiesDefinition(this.resModel, searchItem.fieldName);
 
         const searchItemIds = new Set();
         const existingFieldProperties = {};
@@ -1052,6 +1047,87 @@ export class SearchModel extends EventBus {
     // Private methods
     //--------------------------------------------------------------------------
 
+    /**
+     * Because it require a RPC to get the properties search views items,
+     * it's done lazily, only when we need them.
+     */
+    async fillSearchViewItemsProperty() {
+        if (!this.searchViewFields) {
+            return;
+        }
+
+        const fields = Object.values(this.searchViewFields);
+
+        for (const field of fields) {
+            if (field.type !== "properties") {
+                continue;
+            }
+
+            const result = await this._fetchPropertiesDefinition(this.resModel, field.name);
+
+            const searchItemsNames = Object.values(this.searchItems)
+                .filter((item) => item.isProperty && ["groupBy", "dateGroupBy"].includes(item.type))
+                .map((item) => item.fieldName);
+
+            for (const { definitionRecordId, definitionRecordName, definitions } of result) {
+                // some properties might have been deleted
+                const groupNames = definitions.map(
+                    (definition) => `group_by_${field.name}.${definition.name}`
+                );
+                Object.values(this.searchItems).forEach((searchItem) => {
+                    if (
+                        searchItem.isProperty &&
+                        searchItem.definitionRecordId === definitionRecordId &&
+                        ["groupBy", "dateGroupBy"].includes(searchItem.type) &&
+                        !groupNames.includes(searchItem.name)
+                    ) {
+                        // we can not just remove the element from the list because index are used as id
+                        // so we use a different type to hide it everywhere (until the user refresh his
+                        // browser and the item won't be created again)
+                        searchItem.type = "group_by_property_deleted";
+                    }
+                });
+
+                for (const definition of definitions) {
+                    // we need the definition of the "field" (fake field, property) to be
+                    // in searchViewFields to be able to have the type, it's description, etc
+                    // the name of the property is stored as "<properties field name>.<property name>"
+                    const fullName = `${field.name}.${definition.name}`;
+                    this.searchViewFields[fullName] = {
+                        name: fullName,
+                        readonly: false,
+                        relation: definition.comodel,
+                        required: false,
+                        searchable: false,
+                        selection: definition.selection,
+                        sortable: true,
+                        store: true,
+                        string: `${definition.string} (${definitionRecordName})`,
+                        type: definition.type,
+                        relatedPropertyField: field,
+                    };
+
+                    if (!searchItemsNames.includes(fullName)) {
+                        const groupByItem = {
+                            description: definition.string,
+                            definitionRecordId,
+                            definitionRecordName,
+                            fieldName: fullName,
+                            fieldType: definition.type,
+                            isProperty: true,
+                            name: `group_by_${field.name}.${definition.name}`,
+                            propertyFieldName: field.name,
+                            type: ["datetime", "date"].includes(definition.type)
+                                ? "dateGroupBy"
+                                : "groupBy",
+                        };
+                        this._createGroupOfSearchItems([groupByItem]);
+                    }
+                }
+            }
+        }
+    }
+
     /**
      * Fetch the properties definitions.
      *
@@ -1064,7 +1140,7 @@ export class SearchModel extends EventBus {
      *          definitions: <list of properties definitions>
      *      }
      */
-    async _fetchPropertiesDefinition(definitionRecordModel, definitionRecordField) {
+    async _fetchPropertiesDefinition(resModel, fieldName) {
         const domain = [];
         if (this.context.active_id) {
             // assume the active id is the definition record
@@ -1072,18 +1148,17 @@ export class SearchModel extends EventBus {
             domain.push(["id", "=", this.context.active_id]);
         }
 
-        const result = await this.orm.webSearchRead(definitionRecordModel, domain, {
-            specification: {
-                display_name: {},
-                [definitionRecordField]: {},
-            },
-        });
-
-        return result.records.map((values) => {
+        const definitions = await this.fieldService.loadPropertyDefinitions(
+            resModel,
+            fieldName,
+            domain
+        );
+        const result = groupBy(Object.values(definitions), (definition) => definition.record_id);
+        return Object.entries(result).map(([recordId, definitions]) => {
             return {
-                definitionRecordId: values.id,
-                definitionRecordName: values.display_name,
-                definitions: values[definitionRecordField],
+                definitionRecordId: parseInt(recordId),
+                definitionRecordName: definitions[0]?.record_name,
+                definitions,
             };
         });
     }
diff --git a/addons/web/static/src/search/utils/misc.js b/addons/web/static/src/search/utils/misc.js
index b6c747537a9..67565bb0a74 100644
--- a/addons/web/static/src/search/utils/misc.js
+++ b/addons/web/static/src/search/utils/misc.js
@@ -23,4 +23,5 @@ export const GROUPABLE_TYPES = [
     "many2one",
     "many2many",
     "selection",
+    "tags",
 ];
diff --git a/addons/web/static/src/views/pivot/pivot_group_by_menu.js b/addons/web/static/src/views/pivot/pivot_group_by_menu.js
index dba07bb77ec..f4dc07bfa7a 100644
--- a/addons/web/static/src/views/pivot/pivot_group_by_menu.js
+++ b/addons/web/static/src/views/pivot/pivot_group_by_menu.js
@@ -4,6 +4,7 @@ import { Dropdown } from "@web/core/dropdown/dropdown";
 import { sortBy } from "@web/core/utils/arrays";
 import { useBus } from "@web/core/utils/hooks";
 import { CustomGroupByItem } from "@web/search/custom_group_by_item/custom_group_by_item";
+import { PropertiesGroupByItem } from "@web/search/properties_group_by_item/properties_group_by_item";
 import { SearchDropdownItem } from "@web/search/search_dropdown_item/search_dropdown_item";
 import { getIntervalOptions } from "@web/search/utils/dates";
 import { FACET_ICONS, GROUPABLE_TYPES } from "@web/search/utils/misc";
@@ -105,7 +106,12 @@ export class PivotGroupByMenu extends Component {
         this.props.onAddCustomGroupBy(fieldName);
     }
 }
-PivotGroupByMenu.components = { CustomGroupByItem, Dropdown, SearchDropdownItem };
+PivotGroupByMenu.components = {
+    CustomGroupByItem,
+    Dropdown,
+    SearchDropdownItem,
+    PropertiesGroupByItem,
+};
 PivotGroupByMenu.template = "web.PivotGroupByMenu";
 PivotGroupByMenu.defaultProps = {
     showCaretDown: false,
diff --git a/addons/web/static/src/views/pivot/pivot_group_by_menu.xml b/addons/web/static/src/views/pivot/pivot_group_by_menu.xml
index caf250720ff..b091ffc121d 100644
--- a/addons/web/static/src/views/pivot/pivot_group_by_menu.xml
+++ b/addons/web/static/src/views/pivot/pivot_group_by_menu.xml
@@ -15,7 +15,10 @@
                 <t t-if="currentGroup !== null and currentGroup !== item.groupNumber">
                     <div class="dropdown-divider" role="separator"/>
                 </t>
-                <t t-if="item.options">
+                <t t-if="item.fieldType === 'properties'">
+                    <PropertiesGroupByItem item="item" onGroup.bind="onGroupBySelected"/>
+                </t>
+                <t t-elif="item.options">
                     <Dropdown togglerClass="'o_menu_item' + (item.isActive ? ' selected' : '')">
                         <t t-set-slot="toggler">
                             <t t-esc="item.description"/>
diff --git a/addons/web/static/tests/core/field_service_tests.js b/addons/web/static/tests/core/field_service_tests.js
index 454bd4cc0bb..c18fe3249ce 100644
--- a/addons/web/static/tests/core/field_service_tests.js
+++ b/addons/web/static/tests/core/field_service_tests.js
@@ -22,6 +22,7 @@ function getDefinitions() {
                 is_property: true,
                 searchable: true,
                 record_name: record.display_name,
+                record_id: record.id,
                 ...definition,
             };
         }
diff --git a/addons/web/static/tests/search/search_bar_menu_tests.js b/addons/web/static/tests/search/search_bar_menu_tests.js
index 8368fe888a6..7c7e60ec77d 100644
--- a/addons/web/static/tests/search/search_bar_menu_tests.js
+++ b/addons/web/static/tests/search/search_bar_menu_tests.js
@@ -8,6 +8,7 @@ import {
     getNodesTextContent,
     patchDate,
     patchWithCleanup,
+    nextTick,
 } from "@web/../tests/helpers/utils";
 import { browser } from "@web/core/browser/browser";
 import {
@@ -64,6 +65,24 @@ QUnit.module("Search", (hooks) => {
                             store: true,
                             sortable: true,
                         },
+                        properties: {
+                            string: "Properties",
+                            type: "properties",
+                            definition_record: "parent_id",
+                            definition_record_field: "properties_definition",
+                            name: "properties",
+                        },
+                        parent_id: {
+                            string: "Parent",
+                            type: "many2one",
+                            relation: "parentModel",
+                            name: "parent_id",
+                        },
+                    },
+                },
+                parentModel: {
+                    fields: {
+                        properties_definition: { type: "properties_definition" },
                     },
                 },
             },
@@ -1905,5 +1924,122 @@ QUnit.module("Search", (hooks) => {
                 ["id", "=", 2],
             ]);
         });
+
+        QUnit.test("group by properties", async function (assert) {
+            assert.expect(11);
+
+            async function mockRPC(route, { method, model, args, kwargs }) {
+                if (method === "web_search_read" && model === "parentModel") {
+                    assert.step("definitionFetched");
+                    const records = [
+                        {
+                            id: 1337,
+                            display_name: "First Parent",
+                            properties_definition: [
+                                {
+                                    name: "my_text",
+                                    type: "text",
+                                    string: "My Text",
+                                },
+                                {
+                                    name: "my_partner",
+                                    type: "many2one",
+                                    string: "My Partner",
+                                    comodel: "res.partner",
+                                },
+                                {
+                                    name: "my_datetime",
+                                    type: "datetime",
+                                    string: "My Datetime",
+                                },
+                            ],
+                        },
+                        {
+                            id: 1338,
+                            display_name: "Second Parent",
+                            properties_definition: [
+                                {
+                                    name: "my_integer",
+                                    type: "integer",
+                                    string: "My Integer",
+                                },
+                            ],
+                        },
+                    ];
+                    return { records };
+                }
+            }
+
+            patchWithCleanup(browser, { setTimeout: (fn) => fn() });
+
+            const searchBar = await makeWithSearch({
+                serverData,
+                resModel: "foo",
+                Component: SearchBar,
+                searchViewId: false,
+                searchViewArch: `
+                    <search>
+                        <filter string="Properties" name="properties" context="{'group_by': 'properties'}"/>
+                    </search>
+                `,
+                hideCustomGroupBy: true,
+                searchMenuTypes: ["groupBy"],
+                mockRPC,
+            });
+
+            // definition is fetched only when we open the properties menu
+            assert.verifySteps([]);
+
+            await click(target, ".o_searchview_dropdown_toggler");
+
+            // definition is fetched only when we open the properties menu
+            assert.verifySteps([]);
+            const items = [...target.querySelectorAll(".o_menu_item")];
+            assert.deepEqual(
+                items.map((item) => item.innerText),
+                ["Properties"]
+            );
+
+            await click(target, ".o_accordion_toggle");
+            await nextTick();
+
+            // now that we open the properties we fetch the definition
+            assert.verifySteps(["definitionFetched"]);
+
+            const propertiesItems = [
+                ...target.querySelectorAll(".o_accordion_values .dropdown-item"),
+            ];
+            assert.deepEqual(
+                propertiesItems.map((item) => item.innerText),
+                [
+                    "My Text (First Parent)",
+                    "My Partner (First Parent)",
+                    "My Datetime (First Parent)",
+                    "My Integer (Second Parent)",
+                ]
+            );
+
+            // open the datetime item
+            await click(propertiesItems[2]);
+
+            const optionsItems = [
+                ...target.querySelectorAll(
+                    ".o_accordion_values .o_accordion_values .dropdown-item"
+                ),
+            ];
+            assert.deepEqual(
+                optionsItems.map((item) => item.innerText),
+                ["Year", "Quarter", "Month", "Week", "Day"]
+            );
+
+            assert.deepEqual(searchBar.env.searchModel.groupBy, []);
+            assert.deepEqual(getFacetTexts(target), []);
+
+            await optionsItems[1].click();
+            await nextTick();
+
+            assert.deepEqual(searchBar.env.searchModel.groupBy, ["properties.my_datetime:quarter"]);
+            assert.deepEqual(getFacetTexts(target), ["My Datetime: Quarter"]);
+        });
     });
 });
diff --git a/addons/web/static/tests/search/search_bar_tests.js b/addons/web/static/tests/search/search_bar_tests.js
index a3ceb8b6a2c..b8e5142a820 100644
--- a/addons/web/static/tests/search/search_bar_tests.js
+++ b/addons/web/static/tests/search/search_bar_tests.js
@@ -52,6 +52,7 @@ QUnit.module("Search", (hooks) => {
                             definition_record: "bar",
                             definition_record_field: "child_properties",
                         },
+                        child_properties: { type: "properties_definition" },
                     },
                     records: [
                         {
@@ -1381,7 +1382,7 @@ QUnit.module("Search", (hooks) => {
             ) {
                 assert.deepEqual(
                     kwargs.domain,
-                    [["id", "=", 2]],
+                    ["&", ["child_properties", "!=", false], ["id", "=", 2]],
                     "Should search only the active parent properties"
                 );
 
diff --git a/odoo/addons/test_new_api/tests/test_properties.py b/odoo/addons/test_new_api/tests/test_properties.py
index f3529c0c765..62751f4cd2b 100644
--- a/odoo/addons/test_new_api/tests/test_properties.py
+++ b/odoo/addons/test_new_api/tests/test_properties.py
@@ -1,16 +1,18 @@
 # -*- coding: utf-8 -*-
 # Part of Odoo. See LICENSE file for full copyright and licensing details.
 
+import datetime
 import json
-
 import unittest
+
 from unittest.mock import patch
 
 from odoo import Command
 
 from odoo.exceptions import AccessError, UserError
+from odoo.osv import expression
 from odoo.tests.common import Form, TransactionCase, users
-from odoo.tools import mute_logger
+from odoo.tools import mute_logger, get_lang
 
 
 class TestPropertiesMixin(TransactionCase):
@@ -2011,3 +2013,877 @@ class PropertiesSearchCase(TestPropertiesMixin):
             for order in orders:
                 with self.assertRaises(UserError), self.assertQueryCount(0):
                     self.env['test_new_api.message'].search(domain=[], order=order)
+
+
+class PropertiesGroupByCase(PropertiesCase):
+    @classmethod
+    def setUpClass(cls):
+        super().setUpClass()
+        cls.message_4 = cls.env['test_new_api.message'].create({
+            'name': 'Test Message',
+            'discussion': cls.discussion_1.id,
+            'author': cls.user.id,
+        })
+
+        cls.messages = cls.message_1 | cls.message_2 | cls.message_3 | cls.message_4
+        cls.env['test_new_api.message'].search([('id', 'not in', cls.messages.ids)]).unlink()
+
+        cls.wrong_discussion_id = cls.env['test_new_api.discussion'].search(
+            [], order="id DESC", limit=1).id + 1000
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_basic(self):
+        Model = self.env['test_new_api.message']
+
+        self.messages.discussion = self.discussion_1
+        # search on text properties
+        self.message_1.attributes = [{
+            'name': 'mychar',
+            'type': 'char',
+            'value': 'qsd',
+            'definition_changed': True,
+        }, {
+            'name': 'myinteger',
+            'type': 'integer',
+            'value': 1337,
+            'definition_changed': True,
+        }]
+        self.message_2.attributes = {'mychar': 'qsd', 'myinteger': 5}
+        self.message_3.attributes = {'mychar': 'boum', 'myinteger': 1337}
+        self.env.flush_all()
+
+        # group by the char property
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[],
+                fields=[],
+                groupby=['attributes.mychar'],
+            )
+
+        self.assertEqual(len(result), 3)
+
+        # check counts
+        count_by_values = {
+            value['attributes.mychar']: value['attributes.mychar_count']
+            for value in result
+        }
+        self.assertEqual(count_by_values['boum'], 1)
+        self.assertEqual(count_by_values['qsd'], 2)
+        self.assertEqual(count_by_values[False], 1)
+
+        # check domains
+        domain_by_values = {
+            value['attributes.mychar']: value['__domain']
+            for value in result
+        }
+        self.assertEqual(domain_by_values['boum'], [('attributes.mychar', '=', 'boum')])
+        self.assertEqual(domain_by_values['qsd'], [('attributes.mychar', '=', 'qsd')])
+        self._check_domains_count(result)
+
+        # group by the integer property
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[],
+                fields=[],
+                groupby=['attributes.myinteger'],
+            )
+
+        self.assertEqual(len(result), 3)
+        count_by_values = {
+            value['attributes.myinteger']: value['attributes.myinteger_count']
+            for value in result
+        }
+
+        self.assertEqual(count_by_values[5], 1)
+        self.assertEqual(count_by_values[1337], 2)
+        self.assertEqual(count_by_values[False], 1)
+
+        # falsy properties
+        self.message_3.attributes = {'mychar': False, 'myinteger': False}
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[],
+                fields=[],
+                groupby=['attributes.myinteger'],
+            )
+
+        self.assertEqual(result[-1]['attributes.myinteger_count'], 2)
+        self.assertEqual(result[-1]['__domain'], [('attributes.myinteger', '=', False)])
+        self._check_domains_count(result)
+
+        # non existing keys in the dict values should be grouped with False value
+        self.env.cr.execute(
+            """
+            UPDATE test_new_api_message
+               SET attributes = '{}'
+             WHERE id = %s
+            """,
+            [self.message_2.id],
+        )
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[],
+                fields=[],
+                groupby=['attributes.myinteger'],
+            )
+
+        self.assertEqual(result[-1]['attributes.myinteger_count'], 3)
+        self.assertEqual(result[-1]['__domain'], [('attributes.myinteger', '=', False)])
+        result = Model.search(result[-1]['__domain'])  # check the domain is correct for the search
+        self.assertEqual(result, self.message_2 | self.message_3 | self.message_4)
+
+        # test the order by
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.myinteger'],
+            orderby='attributes.myinteger ASC'
+        )
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0]['attributes.myinteger'], 1337)
+        self.assertEqual(result[1]['attributes.myinteger'], False)
+
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.myinteger'],
+            orderby='attributes.myinteger DESC'
+        )
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0]['attributes.myinteger'], False)
+        self.assertEqual(result[1]['attributes.myinteger'], 1337)
+        self._check_domains_count(result)
+
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.myinteger', 'name'],
+            orderby='attributes.myinteger DESC',
+            lazy=False,
+        )
+        self.assertEqual(
+            result[0]['__domain'],
+            ['&', ('attributes.myinteger', '=', False), ('name', '=', self.message_1.name)],
+        )
+        self._check_domains_count(result)
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_progress_bar(self):
+        """Test the fallback of "_read_progress_bar" when we read a field non-stored."""
+        Model = self.env['test_new_api.message']
+
+        self.messages.discussion = self.discussion_1
+        self.message_1.attributes = [{
+            'name': 'myinteger',
+            'type': 'integer',
+            'value': 1337,
+            'definition_changed': True,
+        }]
+        self.message_2.attributes = {'myinteger': 5}
+        self.message_3.attributes = {'myinteger': 1337}
+
+        result = Model.read_progress_bar(
+            domain=[],
+            group_by='attributes.myinteger',
+            progress_bar={'field': 'size', 'colors': [0]},
+        )
+        self.assertEqual(result, {'1337': {0: 2}, '5': {0: 1}, 'False': {0: 1}})
+
+    def _properties_field_read_group_date_prepare(self, date_type='date'):
+        # Format in database: 2023-03-29 09:30:16
+        self.messages.discussion = self.discussion_1
+        self.discussion_1.attributes_definition = [{
+            'type': date_type,
+            'name': 'mydate',
+        }]
+        hour = ' 13:05:34' if date_type == 'datetime' else ''
+        # message 5 has a different year
+        # message 6 has a False value
+        # message 7 is in a different discussion
+        self.message_5, self.message_6, self.message_7 = self.env['test_new_api.message'].create([
+                {'discussion': self.discussion_1.id, 'attributes': {'mydate': f'2077-05-02{hour}'}},
+                {'discussion': self.discussion_1.id, 'attributes': {'mydate': False}},
+                {'discussion': self.discussion_2.id},
+        ])
+        self.message_1.attributes = {'mydate': f'2023-01-02{hour}'}
+        self.message_2.attributes = {'mydate': f'2023-02-03{hour}'}
+        self.message_3.attributes = {'mydate': f'2023-01-02{hour}'}
+        self.message_4.attributes = {'mydate': f'2023-02-05{hour}'}
+        self.env.flush_all()
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_date_day(self, date_type='date'):
+        self._properties_field_read_group_date_prepare(date_type)
+        Model = self.env['test_new_api.message']
+
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.mydate:day'],
+            orderby='attributes.mydate DESC',
+        )
+
+        self.assertEqual(len(result), 5)
+        # check values and count
+        self.assertEqual(result[0]['attributes.mydate_count'], 2)
+        self.assertEqual(result[0]['attributes.mydate:day'], False)
+        self.assertEqual(result[1]['attributes.mydate_count'], 1)
+        self.assertEqual(result[1]['attributes.mydate:day'], '02 May 2077')
+        self.assertEqual(result[2]['attributes.mydate_count'], 1)
+        self.assertEqual(result[2]['attributes.mydate:day'], '05 Feb 2023')
+        self.assertEqual(result[3]['attributes.mydate_count'], 1)
+        self.assertEqual(result[3]['attributes.mydate:day'], '03 Feb 2023')
+        self.assertEqual(result[4]['attributes.mydate_count'], 2)
+        self.assertEqual(result[4]['attributes.mydate:day'], '02 Jan 2023')
+        # check domain
+        self.assertEqual(Model.search(result[0]['__domain']), self.message_6 | self.message_7)
+        self.assertEqual(Model.search(result[1]['__domain']), self.message_5)
+        self.assertEqual(Model.search(result[2]['__domain']), self.message_4)
+        self.assertEqual(Model.search(result[3]['__domain']), self.message_2)
+        self.assertEqual(Model.search(result[4]['__domain']), self.message_1 | self.message_3)
+        self._check_domains_count(result)
+
+        # when the order is not specified, the ORM will generate one
+        # based on "attributes.mydate ASC", make sure it works
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.mydate:year'],
+        )
+        self.assertEqual(len(result), 3)
+        self.assertEqual(result[0]['attributes.mydate:year'], '2023')
+        self.assertEqual(result[1]['attributes.mydate:year'], '2077')
+        self.assertEqual(result[2]['attributes.mydate:year'], False)
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_date_quarter(self, date_type='date'):
+        self._properties_field_read_group_date_prepare(date_type)
+        Model = self.env['test_new_api.message']
+
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.mydate:quarter'],
+            orderby='attributes.mydate DESC',
+        )
+
+        self.assertEqual(len(result), 3)
+        # check values and count
+        self.assertEqual(result[0]['attributes.mydate_count'], 2)
+        self.assertEqual(result[0]['attributes.mydate:quarter'], False)
+        self.assertEqual(result[1]['attributes.mydate_count'], 1)
+        self.assertEqual(result[1]['attributes.mydate:quarter'], 'Q2 2077')
+        self.assertEqual(result[2]['attributes.mydate_count'], 4)
+        self.assertEqual(result[2]['attributes.mydate:quarter'], 'Q1 2023')
+        # check domain
+        self.assertEqual(Model.search(result[0]['__domain']), self.message_6 | self.message_7)
+        self.assertEqual(Model.search(result[1]['__domain']), self.message_5)
+        self.assertEqual(
+            Model.search(result[2]['__domain']),
+            self.message_1 | self.message_2 | self.message_3 | self.message_4)
+        self._check_domains_count(result)
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_date_month(self, date_type='date'):
+        self._properties_field_read_group_date_prepare()
+        Model = self.env['test_new_api.message']
+
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.mydate:month'],
+            orderby='attributes.mydate DESC',
+        )
+
+        self.assertEqual(len(result), 4)
+        # check values and count
+        self.assertEqual(result[0]['attributes.mydate_count'], 2)
+        self.assertEqual(result[0]['attributes.mydate:month'], False)
+        self.assertEqual(result[1]['attributes.mydate_count'], 1)
+        self.assertEqual(result[1]['attributes.mydate:month'], 'May 2077')
+        self.assertEqual(result[2]['attributes.mydate_count'], 2)
+        self.assertEqual(result[2]['attributes.mydate:month'], 'February 2023')
+        self.assertEqual(result[3]['attributes.mydate_count'], 2)
+        self.assertEqual(result[3]['attributes.mydate:month'], 'January 2023')
+        # check domain
+        self.assertEqual(Model.search(result[0]['__domain']), self.message_6 | self.message_7)
+        self.assertEqual(Model.search(result[1]['__domain']), self.message_5)
+        self.assertEqual(Model.search(result[2]['__domain']), self.message_2 | self.message_4)
+        self.assertEqual(Model.search(result[3]['__domain']), self.message_1 | self.message_3)
+        self._check_domains_count(result)
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_date_week(self, date_type='date'):
+        first_week_day = int(get_lang(self.env).week_start) - 1
+        self.assertEqual(first_week_day, 6, "First day of the week must be Sunday")
+
+        self._properties_field_read_group_date_prepare()
+        Model = self.env['test_new_api.message']
+
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.mydate:week'],
+            orderby='attributes.mydate DESC',
+        )
+
+        self.assertEqual(len(result), 5)
+        # check values and count
+        self.assertEqual(result[0]['attributes.mydate_count'], 2)
+        self.assertEqual(result[0]['attributes.mydate:week'], False)
+        self.assertEqual(result[1]['attributes.mydate_count'], 1)
+        self.assertEqual(result[1]['attributes.mydate:week'], 'W19 2077')
+        self.assertEqual(result[2]['attributes.mydate_count'], 1)
+        self.assertEqual(result[2]['attributes.mydate:week'], 'W6 2023')
+        self.assertEqual(result[3]['attributes.mydate_count'], 1)
+        self.assertEqual(result[3]['attributes.mydate:week'], 'W5 2023')
+        self.assertEqual(result[4]['attributes.mydate_count'], 2)
+        self.assertEqual(result[4]['attributes.mydate:week'], 'W1 2022')
+        # check domain
+        self.assertEqual(Model.search(result[0]['__domain']), self.message_6 | self.message_7)
+        self.assertEqual(Model.search(result[1]['__domain']), self.message_5)
+        self.assertEqual(Model.search(result[2]['__domain']), self.message_4)
+        self.assertEqual(Model.search(result[3]['__domain']), self.message_2)
+        self.assertEqual(Model.search(result[4]['__domain']), self.message_1 | self.message_3)
+        self._check_domains_count(result)
+
+        # test that the first day of the week in the domain care about the local
+        # (based on the lang, the first day of the week might change)
+        for line in result[1:]:
+            self.assertEqual(line['__domain'][1][1], ">=")
+            self.assertEqual(line['__domain'][2][1], "<")
+            start = datetime.datetime.strptime(line['__domain'][1][2], "%Y-%m-%d")
+            end = datetime.datetime.strptime(line['__domain'][2][2], "%Y-%m-%d")
+            self.assertEqual(start.weekday(), first_week_day)
+            self.assertEqual(end.weekday(), first_week_day)
+
+        # now, first day of the week is "Wednesday"
+        lang = self.env['res.lang'].with_context(active_test=False).search([('code', '=', 'fr_FR')])
+        self.assertEqual(len(lang), 1)
+        lang.write({'active': True, 'week_start': '3'})
+        result = Model.with_context(lang='fr_FR').read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.mydate:week'],
+            orderby='attributes.mydate DESC',
+        )
+        for line in result[1:]:
+            self.assertEqual(line['__domain'][1][1], ">=")
+            self.assertEqual(line['__domain'][2][1], "<")
+            start = datetime.datetime.strptime(line['__domain'][1][2], "%Y-%m-%d")
+            end = datetime.datetime.strptime(line['__domain'][2][2], "%Y-%m-%d")
+            self.assertEqual(start.weekday(), 2, "First day of the week must be Wednesday")
+            self.assertEqual(end.weekday(), 2, "First day of the week must be Wednesday")
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_date_year(self, date_type='date'):
+        self._properties_field_read_group_date_prepare()
+        Model = self.env['test_new_api.message']
+
+        result = Model.read_group(
+            domain=[],
+            fields=[],
+            groupby=['attributes.mydate:year'],
+            orderby='attributes.mydate DESC',
+        )
+
+        self.assertEqual(len(result), 3)
+        # check values and count
+        self.assertEqual(result[0]['attributes.mydate_count'], 2)
+        self.assertEqual(result[0]['attributes.mydate:year'], False)
+        self.assertEqual(result[1]['attributes.mydate_count'], 1)
+        self.assertEqual(result[1]['attributes.mydate:year'], '2077')
+        self.assertEqual(result[2]['attributes.mydate_count'], 4)
+        self.assertEqual(result[2]['attributes.mydate:year'], '2023')
+        # check domain
+        self.assertEqual(Model.search(result[0]['__domain']), self.message_6 | self.message_7)
+        self.assertEqual(Model.search(result[1]['__domain']), self.message_5)
+        self.assertEqual(
+            Model.search(result[2]['__domain']),
+            self.message_1 | self.message_2 | self.message_3 | self.message_4)
+        self._check_domains_count(result)
+
+    def test_properties_field_read_group_datetime_day(self):
+        self.test_properties_field_read_group_date_day('datetime')
+
+    def test_properties_field_read_group_datetime_quarter(self):
+        self.test_properties_field_read_group_date_quarter('datetime')
+
+    def test_properties_field_read_group_datetime_month(self):
+        self.test_properties_field_read_group_date_month('datetime')
+
+    def test_properties_field_read_group_datetime_week(self):
+        self.test_properties_field_read_group_date_week('datetime')
+
+    def test_properties_field_read_group_datetime_year(self):
+        self.test_properties_field_read_group_date_year('datetime')
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_injection(self):
+        Model = self.env['test_new_api.message']
+        self.message_1.attributes = [{
+            'name': 'myinteger',
+            'type': 'integer',
+            'value': 1337,
+            'definition_changed': True,
+        }]
+        self.env.flush_all()
+
+        with self.assertRaises(ValueError), self.assertQueryCount(0):
+            Model.read_group(
+                domain=[],
+                fields=[],
+                groupby=['attributes.myinteger'],
+                orderby='attributes.myinteger OR 1=1 DESC'
+            )
+
+        with self.assertRaises(ValueError), self.assertQueryCount(0):
+            Model.read_group(
+                domain=[],
+                fields=[],
+                groupby=['attributes.myinteger OR 1=1'],
+                orderby='attributes.myinteger DESC'
+            )
+
+        with self.assertRaises(ValueError), self.assertQueryCount(0):
+            Model.read_group(
+                domain=[],
+                fields=[],
+                groupby=['attributes.myinteger:wrongfunction'],
+                orderby='attributes.myinteger DESC'
+            )
+
+    @mute_logger('odoo.fields', 'odoo.models.unlink')
+    def test_properties_field_read_group_many2many(self):
+        Model = self.env['test_new_api.message']
+
+        partners = self.env['test_new_api.partner'].create([
+            {'name': f'Partner {i}'}
+            for i in range(10)
+        ])
+
+        self.discussion_1.attributes_definition = [{
+            'name': 'mypartners',
+            'string': 'Partners',
+            'type': 'many2many',
+            'comodel': 'test_new_api.partner',
+        }]
+
+        self.messages.discussion = self.discussion_1
+
+        self.message_1.attributes = {'mypartners': partners[:5].ids}
+        self.message_2.attributes = {'mypartners': partners[3:8].ids}
+        self.message_3.attributes = {'mypartners': partners[8:].ids}
+
+        (partners[4] | partners[7] | partners[9]).unlink()
+
+        with self.assertQueryCount(4):
+            result = Model.read_group(
+                domain=[('discussion', '!=', self.wrong_discussion_id)],
+                fields=[],
+                groupby=['attributes.mypartners'],
+                lazy=False,
+            )
+
+        self.assertEqual(len(result), 8)
+        existing_partners = partners.exists()
+        self.assertEqual(len(existing_partners), 7)
+        for partner, line in zip(existing_partners, result):
+            self.assertEqual(partner.id, line['attributes.mypartners'][0])
+            self.assertEqual(partner.display_name, line['attributes.mypartners'][1])
+            self.assertEqual(
+                line['__domain'],
+                [
+                    '&',
+                    ('discussion', '!=', self.wrong_discussion_id),
+                    ('attributes.mypartners', 'in', partner.id),
+                ],
+            )
+            # only the fourth partner is in 2 messages
+            self.assertEqual(line['__count'], 2 if partner == partners[3] else 1)
+
+        # message 4 is in a different discussion, so it's value is False
+        self.assertEqual(Model.search(result[-1]['__domain']), self.message_4)
+        self._check_many_falsy_group('mypartners', result)
+        self._check_domains_count(result)
+
+        # now message 1 and 2 will also be in the falsy group
+        partners[:8].unlink()
+        with self.assertQueryCount(4):
+            result = Model.read_group(
+                domain=[('discussion', '!=', self.wrong_discussion_id)],
+                fields=[],
+                groupby=['attributes.mypartners'],
+                lazy=False,
+            )
+
+        self.assertEqual(len(result), 2)
+        self.assertEqual(Model.search(result[-1]['__domain']), self.message_1 | self.message_2 | self.message_4)
+        self._check_many_falsy_group('mypartners', result)
+        self._check_domains_count(result)
+
+        # special case, no partner exists
+        existing_partners.unlink()
+        result = Model.read_group(
+            domain=[('discussion', '!=', self.wrong_discussion_id)],
+            fields=[],
+            groupby=['attributes.mypartners'],
+            lazy=False,
+        )
+        self.assertEqual(len(result), 1)
+        self.assertFalse(result[0]['attributes.mypartners'])
+        self.assertEqual(result[0]['__count'], 4)
+        self._check_domains_count(result)
+
+        # test an invalid model name (e.g. if we uninstalled the module of the model)
+        for invalid_model_name in ("invalid_model_name", "test_new_api.transient_model"):
+            self.env.cr.execute(
+                """
+                UPDATE test_new_api_discussion
+                   SET attributes_definition
+                       = jsonb_set(attributes_definition, '{0,comodel}', %s)
+                 WHERE id = %s
+                """,
+                [json.dumps(invalid_model_name), self.discussion_1.id],
+            )  # bypass the ORM to set an invalid model name
+            definition = self._get_sql_definition(self.discussion_1)
+            self.assertEqual(definition[0]['comodel'], invalid_model_name)
+            with self.assertQueryCount(3):
+                result = Model.read_group(
+                    domain=[('discussion', '!=', self.wrong_discussion_id)],
+                    fields=[],
+                    groupby=['attributes.mypartners'],
+                    lazy=False,
+                )
+
+            self.assertEqual(len(result), 1)
+            self.assertFalse(result[0]['attributes.mypartners'])
+            self.assertEqual(result[0]['__count'], 4)
+            self._check_domains_count(result)
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_many2one(self):
+        Model = self.env['test_new_api.message']
+
+        # group by many2one property
+        self.message_1.attributes = [{
+            'name': 'mypartner',
+            'type': 'many2one',
+            'value': self.partner_2.id,
+            'comodel': 'test_new_api.partner',
+            'definition_changed': True,
+        }]
+        self.message_2.attributes = {'mypartner': self.partner.id}
+        self.message_4.attributes = {'mypartner': False}  # explicit False value
+
+        # this partner id doesn't exist
+        unexisting_record_id = self.env['test_new_api.partner'].search(
+            [], order="id DESC", limit=1).id + 1
+        self.env.cr.execute(
+            """
+            UPDATE test_new_api_message
+               SET attributes = '{"mypartner": %s}'
+             WHERE id = %s
+            """,
+            [unexisting_record_id, self.message_3.id],
+        )
+
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[],
+                fields=['name', 'attributes', 'discussion'],
+                groupby=['attributes.mypartner'],
+            )
+
+        self.assertEqual(len(result), 3, 'Should ignore the partner that has been removed')
+
+        self.assertEqual(result[0]['attributes.mypartner_count'], 1)
+        self.assertEqual(result[0]['attributes.mypartner'][0], self.partner.id)
+        self.assertEqual(result[0]['attributes.mypartner'][1], self.partner.display_name)
+        self.assertEqual(result[0]['__domain'], [('attributes.mypartner', '=', self.partner.id)])
+
+        self.assertEqual(result[1]['attributes.mypartner_count'], 1)
+        self.assertEqual(result[1]['attributes.mypartner'][0], self.partner_2.id)
+        self.assertEqual(result[1]['attributes.mypartner'][1], self.partner_2.display_name)
+        self.assertEqual(result[1]['__domain'], [('attributes.mypartner', '=', self.partner_2.id)])
+
+        # falsy domain, automatically generated, contains the false value
+        # and the ids of the records that doesn't exist in the database
+        self.assertEqual(result[2]['attributes.mypartner_count'], 2)
+        self.assertEqual(result[2]['attributes.mypartner'], False)
+        self.assertEqual(
+            result[2]['__domain'],
+            [
+                '|',
+                ('attributes.mypartner', '=', False),
+                ('attributes.mypartner', 'not in', (self.partner.id, self.partner_2.id)),
+            ],
+        )
+
+        # when there's no "('property', '=', False)" domain, it should be created
+        self.message_4.attributes = {'mypartner': self.partner.id}
+        result = Model.read_group(
+            domain=[],
+            fields=['name', 'attributes', 'discussion'],
+            groupby=['attributes.mypartner'],
+        )
+        self.assertEqual(result[2]['attributes.mypartner_count'], 1)
+        self.assertEqual(
+            result[2]['__domain'],
+            [
+                '|',
+                ('attributes.mypartner', '=', False),
+                ('attributes.mypartner', 'not in', (self.partner.id, self.partner_2.id)),
+            ],
+        )
+
+        # test an invalid model name (e.g. if we uninstalled the module of the model)
+        # should have only one group with the value "False", and all records
+        for invalid_model_name in ("invalid_model_name", "test_new_api.transient_model"):
+            self.env.cr.execute(
+                """
+                UPDATE test_new_api_discussion
+                   SET attributes_definition
+                       = jsonb_set(attributes_definition, '{0,comodel}', %s::jsonb)
+                 WHERE id = %s
+                """,
+                [json.dumps(invalid_model_name), self.discussion_1.id],
+            )  # bypass the ORM to set an invalid model name
+            definition = self._get_sql_definition(self.discussion_1)
+            self.assertEqual(definition[0]['comodel'], invalid_model_name)
+            with self.assertQueryCount(3):
+                result = Model.read_group(
+                    domain=[('discussion', '!=', self.wrong_discussion_id)],
+                    fields=[],
+                    groupby=['attributes.mypartner'],
+                    lazy=False,
+                )
+
+            self.assertEqual(len(result), 1)
+            self.assertEqual(result[0]['__count'], 4)
+            self._check_domains_count(result)
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_selection(self):
+        Model = self.env['test_new_api.message']
+
+        # group by selection property
+        self.message_1.attributes = [{
+            'name': 'myselection',
+            'type': 'selection',
+            'value': 'optionA',
+            'selection': [['optionA', 'A'], ['optionB', 'B']],
+            'definition_changed': True,
+        }, {
+            'name': 'mychar2',
+            'type': 'char',
+            'value': 'qsd',
+            'definition_changed': True,
+        }]
+        self.message_2.attributes = {'myselection': False}
+
+        self.env.cr.execute(
+            """
+            UPDATE test_new_api_message
+               SET attributes = '{"myselection": "invalid_option"}'
+             WHERE id = %s
+            """,
+            [self.message_3.id],
+        )
+
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[('discussion', '!=', self.wrong_discussion_id)],
+                fields=['name', 'attributes', 'discussion'],
+                groupby=['attributes.myselection'],
+            )
+
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0]['attributes.myselection_count'], 1)
+        self.assertEqual(
+            result[0]['__domain'],
+            [
+                '&',
+                ('discussion', '!=', self.wrong_discussion_id),  # original domain should be preserved
+                ('attributes.myselection', '=', 'optionA'),
+            ],
+        )
+        self.assertEqual(result[0]['attributes.myselection'], 'optionA')
+
+        # check that the option that is not valid is included in the "False" domain
+        # the count should be updated as well
+        self.assertEqual(result[1]['attributes.myselection_count'], 3)
+        self.assertEqual(
+            result[1]['__domain'],
+            [
+                '&',
+                ('discussion', '!=', self.wrong_discussion_id),
+                '|',
+                ('attributes.myselection', '=', False),
+                ('attributes.myselection', 'not in', ('optionA', 'optionB')),
+            ],
+        )
+        self.assertEqual(result[1]['attributes.myselection'], False)
+        # double check that the returned domain filter the right record
+        self.assertEqual(
+            self.env['test_new_api.message'].search(result[1]['__domain']),
+            self.message_2 | self.message_3 | self.message_4,
+        )
+
+        # special case, there's no option
+        self.message_1.attributes = [{
+            'name': 'myselection',
+            'type': 'selection',
+            'value': 'optionA',
+            'selection': [],
+            'definition_changed': True,
+        }]
+        self.env.flush_all()
+        result = Model.read_group(
+            domain=[],
+            fields=['attributes'],
+            groupby=['attributes.myselection'],
+        )
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0]['attributes.myselection_count'], 4)
+        self._check_domains_count(result)
+
+    @mute_logger('odoo.fields')
+    def test_properties_field_read_group_tags(self):
+        Model = self.env['test_new_api.message']
+
+        (self.message_1 | self.message_2 | self.message_3).discussion = self.discussion_1
+
+        # group by tags property
+        self.message_1.attributes = [{
+            'name': 'mytags',
+            'type': 'tags',
+            'value': ['a', 'c', 'g'],
+            'tags': [[x.lower(), x, i] for i, x in enumerate('ABCDEFG')],
+            'definition_changed': True,
+        }]
+        self.message_2.attributes = {'mytags': ['a', 'e', 'g']}
+        self.env.cr.execute(
+            """
+            UPDATE test_new_api_message
+               SET attributes = '{"mytags": ["a", "d", "invalid", "e"]}'
+             WHERE id = %s
+            """,
+            [self.message_3.id],
+        )
+        self.env.invalidate_all()
+
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[('discussion', '!=', self.wrong_discussion_id)],
+                fields=[],
+                groupby=['attributes.mytags'],
+                lazy=False,
+            )
+
+        self.assertNotIn('invalid', str(result))
+        self.assertEqual(len(result), 6)
+
+        all_tags = self.message_1.read(['attributes'])[0]['attributes'][0]['tags']
+        all_tags = {tag[0]: tag for tag in all_tags}
+
+        for group, (tag, count) in zip(result, (('a', 3), ('c', 1), ('d', 1), ('e', 2), ('g', 2))):
+            self.assertEqual(group['attributes.mytags'], all_tags[tag])
+            self.assertEqual(group['__count'], count)
+            self.assertEqual(
+                group['__domain'],
+                [
+                    '&',
+                    ('discussion', '!=', self.wrong_discussion_id),
+                    ('attributes.mytags', 'in', tag),
+                ],
+            )
+            # check that the value when we read the record match the value of the group
+            property_values = [
+                next(pro['value'] for pro in values['attributes'])
+                for values in Model.search(group['__domain']).read(['attributes'])
+            ]
+            self.assertTrue(all(tag in property_value for property_value in property_values))
+
+        self.assertEqual(Model.search(result[-1]['__domain']), self.message_4)
+        self._check_many_falsy_group('mytags', result)
+        self._check_domains_count(result)
+
+        # now message 3 has *only* invalid tags, so it should be in the falsy group
+        self.env.cr.execute(
+            """
+            UPDATE test_new_api_message
+               SET attributes = '{"mytags": ["invalid 1", "invalid 2", "invalid 3"]}'
+             WHERE id = %s
+            """,
+            [self.message_3.id],
+        )
+        self.env.invalidate_all()
+
+        with self.assertQueryCount(3):
+            result = Model.read_group(
+                domain=[('discussion', '!=', self.wrong_discussion_id)],
+                fields=[],
+                groupby=['attributes.mytags'],
+                lazy=False,
+            )
+        self.assertEqual(Model.search(result[-1]['__domain']), self.message_3 | self.message_4)
+        self._check_many_falsy_group('mytags', result)
+        self._check_domains_count(result)
+
+        # special case, there's no tag
+        for tags in ([], False, None):
+            self.message_1.attributes = [{
+                'name': 'mytags',
+                'type': 'tags',
+                'value': tags,
+                'tags': tags,
+                'definition_changed': True,
+            }]
+            self.env.flush_all()
+            result = Model.read_group(
+                domain=[('discussion', '!=', self.wrong_discussion_id)],
+                fields=[],
+                groupby=['attributes.mytags'],
+                lazy=False,
+            )
+            self.assertEqual(len(result), 1)
+            self.assertFalse(result[0]['attributes.mytags'])
+            self.assertEqual(result[0]['__count'], 4)
+            self._check_domains_count(result)
+
+    def _check_domains_count(self, result):
+        """Check that the domains in the result match the __count key."""
+        for line in result:
+            records = self.env['test_new_api.message'].search(line['__domain'])
+            count_key = next(key for key in line if "_count" in key)
+            self.assertEqual(len(records), line[count_key])
+
+    def _check_many_falsy_group(self, property_name, result):
+        """Check the falsy group from the many2many and tags read group result.
+
+        - if a record is in the falsy group, it can't be in a other group
+          (that sentence is not true for non-falsy group, a record
+          with a non-falsy value can be in many other groups)
+        - read the value of all records and check if they belongs to the correct group
+        """
+        Model = self.env['test_new_api.message']
+        falsy_group = result[-1]
+        self.assertFalse(falsy_group[f'attributes.{property_name}'])
+        falsy_records = Model.search(falsy_group['__domain'])
+        nonfalsy_records = Model.search(expression.OR([line['__domain'] for line in result[:-1]]))
+        self.assertEqual(Model.search_count([]), len(falsy_records) + len(nonfalsy_records))
+        for falsy_record in falsy_records:
+            self.assertNotIn(falsy_record, nonfalsy_records)
+
+        def _get_records_values(records):
+            return [
+                next(
+                    (pro['value'] for pro in properties['attributes']
+                     if pro['name'] == property_name),
+                )
+                for properties in records.read(['attributes'])
+            ]
+
+        self.assertTrue(not any(_get_records_values(falsy_records)))
+        self.assertTrue(all(_get_records_values(nonfalsy_records)))
diff --git a/odoo/models.py b/odoo/models.py
index 4559f3040b9..cc98824c9bf 100644
--- a/odoo/models.py
+++ b/odoo/models.py
@@ -72,7 +72,7 @@ regex_alphanumeric = re.compile(r'^[a-z0-9_]+$')
 regex_order = re.compile(r'''
     ^
     (\s*
-        ((?P<field>[a-z0-9:_]+|"[a-z0-9:_]+")(\.(?P<property>[a-z0-9_]+))?)
+        (?P<term>((?P<field>[a-z0-9_]+|"[a-z0-9_]+")(\.(?P<property>[a-z0-9_]+))?(:(?P<func>[a-z_]+))?))
         (\s+(?P<direction>desc|asc))?
         (\s+(?P<nulls>nulls\ first|nulls\ last))?
         \s*
@@ -84,7 +84,7 @@ regex_order = re.compile(r'''
 regex_object_name = re.compile(r'^[a-z0-9_.]+$')
 regex_pg_name = re.compile(r'^[a-z_][a-z0-9_$]*$', re.I)
 regex_field_agg = re.compile(r'(\w+)(?::(\w+)(?:\((\w+)\))?)?')  # For read_group
-regex_read_group_spec = re.compile(r'(\w+)(?::(\w+))?$')  # For _read_group
+regex_read_group_spec = re.compile(r'(\w+)(\.(\w+))?(?::(\w+))?$')  # For _read_group
 
 AUTOINIT_RECALCULATE_STORED_FIELDS = 1000
 
@@ -92,15 +92,17 @@ INSERT_BATCH_SIZE = 100
 SQL_DEFAULT = psycopg2.extensions.AsIs("DEFAULT")
 
 def parse_read_group_spec(spec: str) -> tuple:
-    """ Return a pair corresponding to the given groupby/aggregate specification. """
+    """ Return a triplet corresponding to the given groupby/path/aggregate specification. """
     res_match = regex_read_group_spec.match(spec)
     if not res_match:
         raise ValueError(
             f'Invalid aggregate/groupby specification {spec!r}.\n'
             '- Valid aggregate specification looks like "<field_name>:<agg>" example: "quantity:sum".\n'
-            '- Valid groupby specification looks like "<no_datish_field_name>" or "<datish_field_name>:<granularity>" example: "date:month".'
+            '- Valid groupby specification looks like "<no_datish_field_name>" or "<datish_field_name>:<granularity>" example: "date:month" or "<properties_field_name>.<property>:<granularity>".'
         )
-    return res_match.groups()
+
+    groups = res_match.groups()
+    return groups[0], groups[2], groups[3]
 
 def check_object_name(name):
     """ Check if the given name is a valid model name.
@@ -1858,10 +1860,10 @@ class BaseModel(metaclass=MetaModel):
         query = self._search(domain)
 
         fnames_to_flush = OrderedSet()
-        groupby_terms = []  # [<SQL expression>,]
+        groupby_terms_map = {}  # {spec: <SQL expression>}
         for spec in groupby:
             sql_expression, fnames_used = self._read_group_groupby(spec, query)
-            groupby_terms.append(sql_expression)
+            groupby_terms_map[spec] = sql_expression
             fnames_to_flush.update(fnames_used)
 
         select_terms = []  # [<SQL expression>,]
@@ -1873,9 +1875,11 @@ class BaseModel(metaclass=MetaModel):
         having_expression, having_params, fnames_used = self._read_group_having(having, query)
         fnames_to_flush.update(fnames_used)
 
-        orderby_terms, extra_groupby_terms, fnames_used = self._read_group_orderby(order, groupby, query)
+        orderby_terms, extra_groupby_terms, fnames_used = self._read_group_orderby(order, groupby_terms_map, query)
         fnames_to_flush.update(fnames_used)
 
+        groupby_terms = list(groupby_terms_map.values())
+
         from_clause, where_clause, query_params = query.get_sql()
         query_parts = [
             f"SELECT {', '.join(groupby_terms + select_terms)}",
@@ -1932,12 +1936,14 @@ class BaseModel(metaclass=MetaModel):
         if aggregate_spec == '__count':
             return 'COUNT(*)', []
 
-        fname, func = parse_read_group_spec(aggregate_spec)
+        fname, property_name, func = parse_read_group_spec(aggregate_spec)
+
+        access_fname = f"{fname}.{property_name}" if property_name else fname
 
         if fname not in self:
             raise ValueError(f"Invalid field {fname!r} on model {self._name!r} for {aggregate_spec!r}.")
         if not func:
-            raise ValueError(f"Aggregate method is mandatory for {fname!r}")
+            raise ValueError(f"Aggregate method is mandatory for {access_fname!r}")
         if func not in READ_GROUP_AGGREGATE:
             raise ValueError(f"Invalid aggregate method {func!r} for {aggregate_spec!r}.")
 
@@ -1945,7 +1951,7 @@ class BaseModel(metaclass=MetaModel):
         if func == 'recordset' and not (field.relational or fname == 'id'):
             raise ValueError(f"Aggregate method {func!r} can be only used on relational field (or id) (for {aggregate_spec!r}).")
 
-        field_expression = self._inherits_join_calc(self._table, fname, query)
+        field_expression = self._inherits_join_calc(self._table, access_fname, query)
 
         expression = READ_GROUP_AGGREGATE[func](self._table, field_expression)
         return expression, [fname]
@@ -1955,24 +1961,33 @@ class BaseModel(metaclass=MetaModel):
         """ Return a pair (<SQL expression>, [<field names used in SQL expression>])
         corresponding to the given groupby element.
         """
-        fname, granularity = parse_read_group_spec(groupby_spec)
+        fname, property_name, granularity = parse_read_group_spec(groupby_spec)
         if fname not in self:
             raise ValueError(f"Invalid field {fname!r} on model {self._name!r}")
 
         field = self._fields[fname]
 
-        if granularity and field.type not in ('datetime', 'date'):
-            raise ValueError(f"Granularity set on a no-datetime field: {groupby_spec!r}")
+        if property_name:
+            check_property_field_value_name(property_name)
+            if field.type != "properties":
+                raise ValueError(f"Property set on a non properties field: {property_name!r}")
+
+            access_fname = f"{fname}.{property_name}"
+        else:
+            access_fname = fname
+
+        if granularity and field.type not in ('datetime', 'date', 'properties'):
+            raise ValueError(f"Granularity set on a no-datetime field or property: {groupby_spec!r}")
 
         if not field.store and not field.inherited:  # TODO: should be manage by _inherits_join_calc
             raise ValueError(f"Groupby on no-store field: {groupby_spec!r}")
 
-        field_expression = self._inherits_join_calc(self._table, fname, query)
+        field_expression = self._inherits_join_calc(self._table, access_fname, query)
         if field.type == 'datetime' and self.env.context.get('tz') in pytz.all_timezones_set:
             # TODO: `self.env.context.get('tz')` should be passed as args
             field_expression = f"timezone('{self.env.context.get('tz')}', timezone('UTC', {field_expression}))"
 
-        if field.type in ('datetime', 'date'):
+        if field.type in ('datetime', 'date') or (field.type == 'properties' and granularity):
             if not granularity:
                 raise ValueError(f"Granularity not set on a date(time) field: {groupby_spec!r}")
             if granularity not in READ_GROUP_TIME_GRANULARITY:
@@ -2033,14 +2048,18 @@ class BaseModel(metaclass=MetaModel):
         return expr, params, fnames_used
 
     @api.model
-    def _read_group_orderby(self, order, groupby, query):
+    def _read_group_orderby(self, order, groupby_terms, query):
         """ Return ([<SQL expression>], [<SQL expression>], [<field names used>])
         corresponding to the given order and groupby terms.
+
+        :param order: The order to use in SQL format
+        :param groupby_terms: The group by terms ({spec: sql_expression})
+        :param query: The query we are building
         """
         if order:
             traverse_many2one = True
         else:
-            order = ','.join(groupby)
+            order = ','.join(groupby_terms)
             traverse_many2one = False
 
         orderby_terms = []
@@ -2053,29 +2072,27 @@ class BaseModel(metaclass=MetaModel):
             order_match = regex_order.match(order_part)
             if not order_match:
                 raise ValueError(f"Invalid order {order!r} for _read_group()")
-            order_field = order_match['field']
-            if order_match['property']:
-                raise ValueError(f"Invalid order {order!r} for _read_group(): properties are not supported")
+            order_term = order_match['term']
             order_direction = (order_match['direction'] or 'ASC').upper()
             order_nulls = (order_match['nulls'] or '').upper()
 
-            if order_field not in groupby:
+            if order_term not in groupby_terms:
                 try:
-                    sql_expression, fnames_used_select = self._read_group_select(order_field, query)
+                    sql_expression, fnames_used_select = self._read_group_select(order_term, query)
                     fnames_used.extend(fnames_used_select)
                     orderby_terms.append(f'{sql_expression} {order_direction} {order_nulls}')
                     continue
                 except ValueError as e:
                     raise ValueError(f"Order term {order_part!r} is not a valid aggregate nor valid groupby") from e
 
-            if traverse_many2one and order_field in self and self._fields[order_field].type == 'many2one':
+            if traverse_many2one and order_term in self and self._fields[order_term].type == 'many2one':
                 # It will generated extra clause to add in the group by.
-                extra_order = self._generate_order_by(f'{order_field} {order_direction} {order_nulls}', query)
+                extra_order = self._generate_order_by(f'{order_term} {order_direction} {order_nulls}', query)
                 extra_order = extra_order.replace(' ORDER BY ', '')
                 orderby_terms.extend(order.strip() for order in extra_order.split(",") if order.strip())
                 extra_groupby_terms.extend(order.strip().split()[0] for order in extra_order.split(",") if order.strip())
             else:
-                sql_expression, __ = self._read_group_groupby(order_field, query)
+                sql_expression = groupby_terms[order_term]
                 orderby_terms.append(f'{sql_expression} {order_direction} {order_nulls}')
 
         return orderby_terms, extra_groupby_terms, fnames_used
@@ -2090,7 +2107,7 @@ class BaseModel(metaclass=MetaModel):
         """ Return the empty value corresponding to the given groupby spec or aggregate spec. """
         if spec == '__count':
             return 0
-        fname, func = parse_read_group_spec(spec)  # func is either None, granularity or an aggregate
+        fname, __, func = parse_read_group_spec(spec)  # func is either None, granularity or an aggregate
         if func in ('count', 'count_distinct'):
             return 0
         if func == 'array_agg':
@@ -2110,7 +2127,7 @@ class BaseModel(metaclass=MetaModel):
         """
         empty_value = self._read_group_empty_value(groupby_spec)
 
-        fname, __ = parse_read_group_spec(groupby_spec)
+        fname, *__ = parse_read_group_spec(groupby_spec)
         field = self._fields[fname]
 
         if field.relational or fname == 'id':
@@ -2137,7 +2154,7 @@ class BaseModel(metaclass=MetaModel):
         if aggregate_spec == '__count':
             return ((value if value is not None else empty_value) for value in raw_values)
 
-        fname, func = parse_read_group_spec(aggregate_spec)
+        fname, __, func = parse_read_group_spec(aggregate_spec)
         if func == 'recordset':
             field = self._fields[fname]
             Model = self.pool[field.comodel_name] if field.relational else self.pool[self._name]
@@ -2166,7 +2183,7 @@ class BaseModel(metaclass=MetaModel):
     def _read_group_fill_results(self, domain, groupby, annoted_aggregates, read_group_result, read_group_order=None):
         """Helper method for filling in empty groups for all possible values of
            the field being grouped by"""
-        field_name, __ = groupby.split(':') if ':' in groupby else (groupby, 'month')
+        field_name = groupby.split('.')[0].split(':')[0]
         field = self._fields[field_name]
         if not field or not field.group_expand:
             return read_group_result
@@ -2326,9 +2343,9 @@ class BaseModel(metaclass=MetaModel):
         """
         # TODO: remove min_groups
         first_group = groupby[0]
-        field_name = first_group.split(':')[0]
+        field_name = first_group.split(':')[0].split(".")[0]
         field = self._fields[field_name]
-        if field.type not in ('date', 'datetime'):
+        if field.type not in ('date', 'datetime') and not (field.type == 'properties' and ':' in first_group):
             return data
 
         granularity = first_group.split(':')[1] if ':' in first_group else 'month'
@@ -2408,11 +2425,9 @@ class BaseModel(metaclass=MetaModel):
         :param data: a single group
         :param annotated_groupbys: expanded grouping metainformation
         :param groupby: original grouping metainformation
-        :param domain: original domain for read_group
         """
-
         for group in lazy_groupby:
-            field_name = group.split(':')[0]
+            field_name = group.split(':')[0].split('.')[0]
             field = self._fields[field_name]
 
             if field.type in ('date', 'datetime'):
@@ -2421,6 +2436,10 @@ class BaseModel(metaclass=MetaModel):
                 granularity = group.split(':')[1] if ':' in group else 'month'
                 interval = READ_GROUP_TIME_GRANULARITY[granularity]
 
+            elif field.type == "properties":
+                self._read_group_format_result_properties(rows_dict, group)
+                continue
+
             for row in rows_dict:
                 value = row[group]
 
@@ -2468,6 +2487,123 @@ class BaseModel(metaclass=MetaModel):
 
                 row['__domain'] = expression.AND([row['__domain'], additional_domain])
 
+    def _read_group_format_result_properties(self, rows_dict, group):
+        """Modify the final read group properties result.
+
+        Replace the relational properties ids by a tuple with their display names,
+        replace the "raw" tags and selection values by a list containing their labels.
+        Adapt the domains for the Falsy group (we can't just keep (selection, =, False)
+        e.g. because some values in database might correspond to  option that have
+        been remove on the parent).
+        """
+        if '.' not in group:
+            raise ValueError('You must choose the property you want to group by.')
+        fullname, __, func = group.partition(':')
+
+        definition = self.get_property_definition(fullname)
+        property_type = definition.get('type')
+
+        if property_type == 'selection':
+            options = definition.get('selection') or []
+            options = tuple(option[0] for option in options)
+            for row in rows_dict:
+                if not row[fullname]:
+                    # can not do ('selection', '=', False) because we might have
+                    # option in database that does not exist anymore
+                    additional_domain = expression.OR([
+                        [(fullname, '=', False)],
+                        [(fullname, 'not in', options)],
+                    ])
+                else:
+                    additional_domain = [(fullname, '=', row[fullname])]
+
+                row['__domain'] = expression.AND([row['__domain'], additional_domain])
+
+        elif property_type == 'many2one':
+            comodel = definition.get('comodel')
+            prefetch_ids = tuple(row[fullname] for row in rows_dict if row[fullname])
+            all_groups = tuple(row[fullname] for row in rows_dict if row[fullname])
+            for row in rows_dict:
+                if not row[fullname]:
+                    # can not only do ('many2one', '=', False) because we might have
+                    # record in database that does not exist anymore
+                    additional_domain = expression.OR([
+                        [(fullname, '=', False)],
+                        [(fullname, 'not in', all_groups)],
+                    ])
+                else:
+                    additional_domain = [(fullname, '=', row[fullname])]
+                    record = self.env[comodel].browse(row[fullname]).with_prefetch(prefetch_ids)
+                    row[fullname] = (row[fullname], record.display_name)
+
+                row['__domain'] = expression.AND([row['__domain'], additional_domain])
+
+        elif property_type == 'many2many':
+            comodel = definition.get('comodel')
+            prefetch_ids = tuple(row[fullname] for row in rows_dict if row[fullname])
+            all_groups = tuple(row[fullname] for row in rows_dict if row[fullname])
+            for row in rows_dict:
+                if not row[fullname]:
+                    additional_domain = expression.OR([
+                        [(fullname, '=', False)],
+                        expression.AND([[(fullname, 'not in', group)] for group in all_groups]),
+                    ]) if all_groups else []
+                else:
+                    additional_domain = [(fullname, 'in', row[fullname])]
+                    record = self.env[comodel].browse(row[fullname]).with_prefetch(prefetch_ids)
+                    row[fullname] = (row[fullname], record.display_name)
+
+                row['__domain'] = expression.AND([row['__domain'], additional_domain])
+
+        elif property_type == 'tags':
+            tags = definition.get('tags') or []
+            tags = {tag[0]: tag for tag in tags}
+            for row in rows_dict:
+                if not row[fullname]:
+                    additional_domain = expression.OR([
+                        [(fullname, '=', False)],
+                        expression.AND([[(fullname, 'not in', tag)] for tag in tags]),
+                    ]) if tags else []
+                else:
+                    additional_domain = [(fullname, 'in', row[fullname])]
+                    # replace tag raw value with list of raw value, label and color
+                    row[fullname] = tags.get(row[fullname])
+
+                row['__domain'] = expression.AND([row['__domain'], additional_domain])
+
+        elif property_type in ('date', 'datetime'):
+            for row in rows_dict:
+                if not row[group]:
+                    row[group] = False
+                    row['__domain'] = expression.AND([row['__domain'], [(fullname, '=', False)]])
+                    row['__range'] = {}
+                    continue
+
+                # Date / Datetime are not JSONifiable, so they are stored as raw text
+                db_format = '%Y-%m-%d' if property_type == 'date' else '%Y-%m-%d %H:%M:%S'
+
+                if func == 'week':
+                    # the value is the first day of the week (based on local)
+                    start = row[group].strftime(db_format)
+                    end = (row[group] + datetime.timedelta(days=7)).strftime(db_format)
+                else:
+                    start = (date_utils.start_of(row[group], func)).strftime(db_format)
+                    end = (date_utils.end_of(row[group], func) + datetime.timedelta(minutes=1)).strftime(db_format)
+
+                row['__domain'] = expression.AND([
+                    row['__domain'],
+                    [(fullname, '>=', start), (fullname, '<', end)],
+                ])
+                row['__range'] = {group: {'from': start, 'to': end}}
+                row[group] = babel.dates.format_date(
+                    row[group],
+                    format=READ_GROUP_DISPLAY_FORMAT[func],
+                    locale=get_lang(self.env).code
+                )
+        else:
+            for row in rows_dict:
+                row['__domain'] = expression.AND([row['__domain'], [(fullname, '=', row[fullname])]])
+
     @api.model
     def read_group(self, domain, fields, groupby, offset=0, limit=None, orderby=False, lazy=True):
         """Get the list of records in list view grouped by the given ``groupby`` fields.
@@ -2516,10 +2652,12 @@ class BaseModel(metaclass=MetaModel):
         # - Modify the order to be compatible with the _read_group specification
         annoted_groupby = {}  # Key as the name in the result, value as the explicit groupby specification
         for group_spec in lazy_groupby:
-            field_name, granularity = parse_read_group_spec(group_spec)
+            field_name, property_name, granularity = parse_read_group_spec(group_spec)
             if field_name not in self._fields:
                 raise ValueError(f"Invalid field {field_name!r} on model {self._name!r}")
             field = self._fields[field_name]
+            if property_name and field.type != 'properties':
+                raise ValueError(f"Property name {property_name!r} has to be used on a property field.")
             if field.type in ('date', 'datetime'):
                 annoted_groupby[group_spec] = f"{field_name}:{granularity or 'month'}"
             else:
@@ -2613,6 +2751,11 @@ class BaseModel(metaclass=MetaModel):
         :param query: query object on which the JOIN should be added
         :return: qualified name of field, to be used in SELECT clause
         """
+        property_name = None
+        if '.' in fname:
+            fname, property_name = fname.split('.', 1)
+            check_property_field_value_name(property_name)
+
         # INVARIANT: alias is the SQL alias of model._table in query
         model, field = self, self._fields[fname]
         while field.inherited:
@@ -2650,9 +2793,127 @@ class BaseModel(metaclass=MetaModel):
             if lang == 'en_US':
                 return f'"{alias}"."{fname}"->>\'en_US\''
             return f'COALESCE("{alias}"."{fname}"->>\'{lang}\', "{alias}"."{fname}"->>\'en_US\')'
+        elif field.type == 'properties' and property_name:
+            return self._inherits_join_calc_properties(alias, fname, query, property_name)
         else:
             return '"%s"."%s"' % (alias, fname)
 
+    @api.model
+    def _inherits_join_calc_properties(self, alias, fname, query, property_name):
+        definition = self.get_property_definition(f"{fname}.{property_name}")
+        property_sql = f""""{alias}"."{fname}" -> '{property_name}'"""
+        property_type = definition.get('type')
+        property_alias = tools._generate_table_alias(alias, f'{fname}_{property_name}')
+
+        # JOIN on the JSON array
+        if property_type in ('tags', 'many2many'):
+            property_sql = f'''
+                CASE
+                     WHEN jsonb_typeof({property_sql}) = 'array'
+                     THEN {property_sql}
+                     ELSE '[]'::jsonb
+                 END
+            '''
+            join_property = f'LEFT JOIN jsonb_array_elements({property_sql}) {property_alias}'
+            if property_type == 'tags':
+                # ignore invalid tags
+                tags = [tag[0] for tag in definition.get('tags') or []]
+                # `->>0 : convert "JSON string" into string
+                expr = f'{join_property} ON {property_alias}->>0 = ANY(%s::text[])'
+                query._raw_joins[expr] = [tags]
+
+            elif property_type == 'many2many':
+                comodel = self.env.get(definition.get('comodel'))
+                if comodel is None or comodel._transient or comodel._abstract:
+                    # all value are false, because the model does not exist anymore
+                    # (or is a transient model e.g.)
+                    query._raw_joins[f'{join_property} ON FALSE'] = []
+                else:
+                    # check the existences of the many2many
+                    expr = f'{join_property} ON {property_alias}::int IN (SELECT id FROM {comodel._table})'
+                    query._raw_joins[expr] = []
+
+            return property_alias
+
+        elif property_type == 'selection':
+            options = definition.get('selection') or []
+            options = [option[0] for option in options]
+
+            # check the existence of the option
+            expr = f'''
+                LEFT JOIN (SELECT unnest(%s::text[]) {property_alias}) {property_alias}
+                       ON {property_sql}->>0 = {property_alias}
+            '''
+            query._raw_joins[expr] = [options]
+
+            return property_alias
+
+        elif property_type == 'many2one':
+            comodel = self.env.get(definition.get('comodel'))
+            if comodel is None or comodel._transient or comodel._abstract:
+                # all value are false, because the model does not exist anymore
+                # (or is a transient model e.g.)
+                return 'FALSE'
+
+            return f'''
+                CASE
+                    WHEN jsonb_typeof({property_sql}) = 'number'
+                     AND ({property_sql})::int IN (SELECT id FROM {comodel._table})
+                    THEN {property_sql}
+                    ELSE NULL
+                 END
+            '''
+
+        elif property_type == 'date':
+            return f'''
+                CASE
+                    WHEN jsonb_typeof({property_sql}) = 'string'
+                    THEN ({property_sql}->>0)::DATE
+                    ELSE NULL
+                 END
+            '''
+
+        elif property_type == 'datetime':
+            return f'''
+                CASE
+                    WHEN jsonb_typeof({property_sql}) = 'string'
+                    THEN to_timestamp({property_sql}->>0, 'YYYY-MM-DD HH24:MI:SS')
+                    ELSE NULL
+                 END
+            '''
+
+        # if the key is not present in the dict, fallback to false instead of none
+        return f"COALESCE({property_sql}, 'false')"
+
+    @api.model
+    def get_property_definition(self, full_name):
+        """Return the definition of the given property.
+
+        :param full_name: Name of the field / property
+            (e.g. "property.integer")
+        """
+        self.check_access_rights("read")
+        field_name, property_name = full_name.split(".")
+        check_property_field_value_name(property_name)
+        if field_name not in self._fields:
+            raise ValueError(f"Wrong field name {field_name!r}.")
+
+        field = self._fields[field_name]
+        target_model = self.env[self._fields[field.definition_record].comodel_name]
+        query = psycopg2.sql.SQL("""
+            SELECT definition
+              FROM {table},
+                   jsonb_array_elements({field}) definition
+             WHERE {field} IS NOT NULL
+               AND definition->>'name' = %(property_name)s
+             LIMIT 1
+        """).format(
+            table=psycopg2.sql.Identifier(target_model._table),
+            field=psycopg2.sql.Identifier(field.definition_record_field))
+        self.env.cr.execute(query, {'property_name': property_name})
+        result = self.env.cr.dictfetchone()
+        return result["definition"] if result else {}
+
     def _parent_store_compute(self):
         """ Compute parent_path field from scratch. """
         if not self._parent_store:
@@ -3534,10 +3795,6 @@ class BaseModel(metaclass=MetaModel):
                 continue
             assert field.store
             (column_fields if field.column_type else other_fields).add(field)
-            if field.type == 'properties':
-                # force calling fields.read for properties field in order to
-                # read all relational properties in batch
-                other_fields.add(field)
 
         # necessary to retrieve the en_US value of fields without a translation
         translated_field_names = [field.name for field in column_fields if field.translate]
@@ -4798,9 +5055,6 @@ class BaseModel(metaclass=MetaModel):
         for order_part in order_spec.split(','):
             order_match = regex_order.match(order_part)
             order_field = order_match['field']
-            property_name = order_match['property']
-            if property_name:
-                check_property_field_value_name(property_name)
             order_direction = (order_match['direction'] or '').upper()
             order_nulls = (order_match['nulls'] or '').upper()
             if reverse_direction:
@@ -4813,6 +5067,12 @@ class BaseModel(metaclass=MetaModel):
             if not field:
                 raise ValueError("Invalid field %r on model %r" % (order_field, self._name))
 
+            property_name = order_match['property']
+            if property_name:
+                check_property_field_value_name(property_name)
+                if field.type != 'properties':
+                    raise ValueError(f'Order a property ({property_name!r}) on a non-properties field ({field.name!r})')
+
             if order_field == 'id':
                 order_by_elements.append(f'"{alias}"."{order_field}" {order_direction} {order_nulls}')
             else:
diff --git a/odoo/tools/query.py b/odoo/tools/query.py
index 00f1db65037..7cbc7327700 100644
--- a/odoo/tools/query.py
+++ b/odoo/tools/query.py
@@ -57,6 +57,7 @@ class Query(object):
 
         # joins {alias: (kind, table, condition, condition_params)}
         self._joins = {}
+        self._raw_joins = {}  # {query: params}
 
         # holds the list of WHERE clause elements (to be joined with 'AND'), and
         # the list of parameters
@@ -206,6 +207,10 @@ class Query(object):
             joins.append(f'{kind} {_from_table(table, alias)} ON ({condition})')
             params.extend(condition_params)
 
+        for join_query, query_params in self._raw_joins.items():
+            joins.append(join_query)
+            params.extend(query_params)
+
         from_clause = " ".join([", ".join(tables)] + joins)
         where_clause = " AND ".join(self._where_clauses)
         return from_clause, where_clause, params + self._where_params

From 2943106d875c5ab071995d80646e6a7aaca6e6a6 Mon Sep 17 00:00:00 2001
From: std-odoo <std@odoo.com>
Date: Fri, 7 Apr 2023 12:03:58 +0200
Subject: [PATCH 5/6] [IMP] project, crm: group by properties

Purpose
=======
Allow to group records per properties.

Task-3032464

Part-of: odoo/odoo#103510
---
 addons/crm/views/crm_lead_views.xml         | 4 ++++
 addons/project/views/project_task_views.xml | 2 ++
 2 files changed, 6 insertions(+)

diff --git a/addons/crm/views/crm_lead_views.xml b/addons/crm/views/crm_lead_views.xml
index aaa5a2fab37..3a22a5a2558 100644
--- a/addons/crm/views/crm_lead_views.xml
+++ b/addons/crm/views/crm_lead_views.xml
@@ -716,6 +716,8 @@
                         <separator orientation="vertical" />
                         <filter string="Creation Date" context="{'group_by':'create_date:month'}" name="month"/>
                         <filter string="Closed Date" name="date_closed" context="{'group_by':'date_closed'}"/>
+                        <separator />
+                        <filter string="Properties" name="group_by_lead_properties" context="{'group_by':'lead_properties'}"/>
                     </group>
                 </search>
             </field>
@@ -1026,6 +1028,8 @@
                         <filter string="Conversion Date" name="date_conversion" context="{'group_by': 'date_conversion'}" groups="crm.group_use_lead"/>
                         <filter string="Expected Closing" name="date_deadline" context="{'group_by':'date_deadline'}"/>
                         <filter string="Closed Date" name="date_closed" context="{'group_by':'date_closed'}"/>
+                        <separator/>
+                        <filter string="Properties" name="group_by_lead_properties" context="{'group_by':'lead_properties'}"/>
                     </group>
                 </search>
             </field>
diff --git a/addons/project/views/project_task_views.xml b/addons/project/views/project_task_views.xml
index 62131f10958..cc24e38502c 100644
--- a/addons/project/views/project_task_views.xml
+++ b/addons/project/views/project_task_views.xml
@@ -79,6 +79,8 @@
                 </filter>
                 <filter name="last_stage_update" position="after">
                     <filter string="Deadline" name="deadline" context="{'group_by': 'date_deadline'}"/>
+                    <separator/>
+                    <filter string="Properties" name="group_by_properties" context="{'group_by': 'task_properties'}"/>
                 </filter>
             </field>
         </record>

From faf5fa102212da5ab66426d5539ac5c68da4e5c8 Mon Sep 17 00:00:00 2001
From: std-odoo <std@odoo.com>
Date: Thu, 31 Aug 2023 13:11:57 +0200
Subject: [PATCH 6/6] [IMP] web: add tests related to the "group by y
 properties" feature

Purpose
=======
Add tests about the group by properties feature, the drag and drop
and the behavior in the pivot view.

Task-3032464

Part-of: odoo/odoo#103510
---
 .../tests/views/kanban/kanban_view_tests.js   | 141 ++++++++++++++++++
 .../static/tests/views/pivot_view_tests.js    | 120 +++++++++++++++
 2 files changed, 261 insertions(+)

diff --git a/addons/web/static/tests/views/kanban/kanban_view_tests.js b/addons/web/static/tests/views/kanban/kanban_view_tests.js
index c68e63b28a7..53a0ea71be1 100644
--- a/addons/web/static/tests/views/kanban/kanban_view_tests.js
+++ b/addons/web/static/tests/views/kanban/kanban_view_tests.js
@@ -209,6 +209,23 @@ QUnit.module("Views", (hooks) => {
                             default: 1,
                         },
                         salary: { string: "Monetary field", type: "monetary" },
+                        properties: {
+                            string: "Properties",
+                            type: "properties",
+                            definition_record: "parent_id",
+                            definition_record_field: "properties_definition",
+                            name: "properties",
+                        },
+                        parent_id: {
+                            string: "Parent",
+                            type: "many2one",
+                            relation: "partner",
+                            name: "parent_id",
+                        },
+                        properties_definition: {
+                            string: "Properties",
+                            type: "properties_definition",
+                        },
                     },
                     records: [
                         {
@@ -223,6 +240,13 @@ QUnit.module("Views", (hooks) => {
                             image: "R0lGODlhAQABAAD/ACwAAAAAAQABAAACAA==",
                             salary: 1750,
                             currency_id: 1,
+                            properties_definition: [
+                                {
+                                    name: "my_char",
+                                    string: "My Char",
+                                    type: "char",
+                                },
+                            ],
                         },
                         {
                             id: 2,
@@ -235,6 +259,15 @@ QUnit.module("Views", (hooks) => {
                             category_ids: [6],
                             salary: 1500,
                             currency_id: 1,
+                            parent_id: 1,
+                            properties: [
+                                {
+                                    name: "my_char",
+                                    string: "My Char",
+                                    type: "char",
+                                    value: "aaa",
+                                },
+                            ],
                         },
                         {
                             id: 3,
@@ -247,6 +280,15 @@ QUnit.module("Views", (hooks) => {
                             category_ids: [7],
                             salary: 2000,
                             currency_id: 2,
+                            parent_id: 1,
+                            properties: [
+                                {
+                                    name: "my_char",
+                                    string: "My Char",
+                                    type: "char",
+                                    value: "bbb",
+                                },
+                            ],
                         },
                         {
                             id: 4,
@@ -259,6 +301,7 @@ QUnit.module("Views", (hooks) => {
                             category_ids: [],
                             salary: 2222,
                             currency_id: 1,
+                            parent_id: 2,
                         },
                     ],
                 },
@@ -13826,4 +13869,102 @@ QUnit.module("Views", (hooks) => {
             );
         }
     );
+
+    QUnit.test("group by properties and drag and drop", async (assert) => {
+        assert.expect(10);
+
+        await makeView({
+            type: "kanban",
+            resModel: "partner",
+            serverData,
+            arch: `
+                <kanban on_create="quick_create">
+                    <field name="product_id"/>
+                    <templates><t t-name="kanban-box">
+                        <div class="oe_kanban_global_click">
+                            <field name="foo"/>
+                            <field name="properties"/>
+                        </div>
+                    </t></templates>
+                </kanban>
+            `,
+            groupBy: ["properties.my_char"],
+            async mockRPC(route, args) {
+                if (route === "/web/dataset/call_kw/partner/web_read_group") {
+                    return {
+                        groups: [
+                            {
+                                "properties.my_char": false,
+                                __domain: [["properties.my_char", "=", false]],
+                                "properties.my_char_count": 2,
+                            },
+                            {
+                                "properties.my_char": "aaa",
+                                __domain: [["properties.my_char", "=", "aaa"]],
+                                "properties.my_char_count": 1,
+                            },
+                            {
+                                "properties.my_char": "bbb",
+                                __domain: [["properties.my_char", "=", "bbb"]],
+                                "properties.my_char_count": 1,
+                            },
+                        ],
+                        length: 3,
+                    };
+                } else if (route === "/web/dataset/call_kw/partner/web_search_read") {
+                    const value = args.kwargs.domain[0][2];
+                    return {
+                        length: 1,
+                        records: [
+                            {
+                                id: value === "aaa" ? 2 : 3,
+                                properties: [
+                                    {
+                                        name: "my_char",
+                                        string: "My Char",
+                                        type: "char",
+                                        value: value,
+                                    },
+                                ],
+                            },
+                        ],
+                    };
+                } else if (route === "/web/dataset/resequence") {
+                    assert.step("resequence");
+                } else if (route === "/web/dataset/call_kw/partner/web_save") {
+                    assert.step("web_save");
+                    const expected = {
+                        properties: [
+                            {
+                                name: "my_char",
+                                string: "My Char",
+                                type: "char",
+                                value: "bbb",
+                            },
+                        ],
+                    };
+                    assert.deepEqual(args.args[1], expected);
+                } else if (route === "/web/dataset/call_kw/partner/get_property_definition") {
+                    assert.step("get_property_definition");
+                    return {
+                        name: "my_char",
+                        type: "char",
+                    };
+                }
+            },
+        });
+
+        assert.verifySteps(["get_property_definition"]);
+        assert.containsN(target, ".o_kanban_group:nth-child(2) .o_kanban_record", 1);
+        assert.containsN(target, ".o_kanban_group:nth-child(3) .o_kanban_record", 1);
+
+        await dragAndDrop(
+            ".o_kanban_group:nth-child(2) .o_kanban_record",
+            ".o_kanban_group:nth-child(3)"
+        );
+
+        assert.verifySteps(["web_save", "resequence"]);
+        assert.containsN(target, ".o_kanban_group:nth-child(2) .o_kanban_record", 0);
+        assert.containsN(target, ".o_kanban_group:nth-child(3) .o_kanban_record", 2);
+    });
 });
diff --git a/addons/web/static/tests/views/pivot_view_tests.js b/addons/web/static/tests/views/pivot_view_tests.js
index add9e8c1a66..e744a3fe4c9 100644
--- a/addons/web/static/tests/views/pivot_view_tests.js
+++ b/addons/web/static/tests/views/pivot_view_tests.js
@@ -125,6 +125,23 @@ QUnit.module("Views", (hooks) => {
                             ],
                             group_operator: "count_distinct",
                         },
+                        properties: {
+                            string: "Properties",
+                            type: "properties",
+                            definition_record: "parent_id",
+                            definition_record_field: "properties_definition",
+                            name: "properties",
+                        },
+                        parent_id: {
+                            string: "Parent",
+                            type: "many2one",
+                            relation: "partner",
+                            name: "parent_id",
+                        },
+                        properties_definition: {
+                            string: "Properties",
+                            type: "properties_definition",
+                        },
                     },
                     records: [
                         {
@@ -137,6 +154,13 @@ QUnit.module("Views", (hooks) => {
                             computed_field: 19,
                             company_type: "company",
                             ref: "product,37",
+                            properties_definition: [
+                                {
+                                    name: "my_char",
+                                    string: "My Char",
+                                    type: "char",
+                                },
+                            ],
                         },
                         {
                             id: 2,
@@ -148,6 +172,15 @@ QUnit.module("Views", (hooks) => {
                             computed_field: 23,
                             company_type: "individual",
                             ref: "product,41",
+                            parent_id: 1,
+                            properties: [
+                                {
+                                    name: "my_char",
+                                    string: "My Char",
+                                    type: "char",
+                                    value: "aaa",
+                                },
+                            ],
                         },
                         {
                             id: 3,
@@ -159,6 +192,15 @@ QUnit.module("Views", (hooks) => {
                             computed_field: 26,
                             company_type: "company",
                             ref: "customer,1",
+                            parent_id: 1,
+                            properties: [
+                                {
+                                    name: "my_char",
+                                    string: "My Char",
+                                    type: "char",
+                                    value: "bbb",
+                                },
+                            ],
                         },
                         {
                             id: 4,
@@ -5636,4 +5678,82 @@ QUnit.module("Views", (hooks) => {
             assert.containsNone(target, ".o_pivot_view table");
         }
     );
+
+    QUnit.test("group by properties in pivot view", async function (assert) {
+        assert.expect(18);
+
+        await makeView({
+            type: "pivot",
+            resModel: "partner",
+            serverData,
+            arch: "<pivot/>",
+            searchViewArch: `
+                <search>
+                    <filter name='group_by_properties' string="Properties" context="{'group_by':'properties'}"/>
+                </search>
+            `,
+            mockRPC(route, args) {
+                if (
+                    route === "/web/dataset/call_kw/partner/web_search_read" &&
+                    args.kwargs.specification?.properties_definition
+                ) {
+                    assert.step("fetch_definition");
+                } else if (
+                    route === "/web/dataset/call_kw/partner/read_group" &&
+                    args.kwargs.groupby?.includes("properties.my_char")
+                ) {
+                    assert.step("read_group");
+                    return [
+                        {
+                            "properties.my_char": false,
+                            __domain: [["properties.my_char", "=", false]],
+                            __count: 2,
+                        },
+                        {
+                            "properties.my_char": "aaa",
+                            __domain: [["properties.my_char", "=", "aaa"]],
+                            __count: 1,
+                        },
+                        {
+                            "properties.my_char": "bbb",
+                            __domain: [["properties.my_char", "=", "bbb"]],
+                            __count: 1,
+                        },
+                    ];
+                }
+            },
+        });
+
+        assert.strictEqual(target.querySelectorAll(".o_value").length, 1);
+        assert.strictEqual(target.querySelector(".o_value").innerText, "4");
+
+        await click(target, ".border-top-0 span");
+        assert.verifySteps([]);
+
+        const propertiesItem = target.querySelector(".o_accordion_toggle");
+        assert.ok(propertiesItem);
+        assert.strictEqual(propertiesItem.innerText, "Properties");
+        await click(propertiesItem);
+
+        await nextTick();
+        assert.verifySteps(["fetch_definition"]);
+
+        await click(target, ".o_accordion_values .o_menu_item");
+
+        await nextTick();
+        assert.verifySteps(["read_group"]);
+
+        const cells = target.querySelectorAll(".o_value");
+        assert.strictEqual(cells.length, 4);
+        assert.strictEqual(cells[0].innerText, "2");
+        assert.strictEqual(cells[1].innerText, "1");
+        assert.strictEqual(cells[2].innerText, "1");
+        assert.strictEqual(cells[3].innerText, "4");
+
+        const columns = target.querySelectorAll(".o_pivot_header_cell_closed");
+        assert.strictEqual(columns.length, 4);
+        assert.strictEqual(columns[0].innerText, "None");
+        assert.strictEqual(columns[1].innerText, "aaa");
+        assert.strictEqual(columns[2].innerText, "bbb");
+    });
 });