wazo-confgend.patch

diff --git a/xivo_dao/asterisk_conf_dao.py b/xivo_dao/asterisk_conf_dao.py
index ab32ce80..807da57d 100644
--- a/xivo_dao/asterisk_conf_dao.py
+++ b/xivo_dao/asterisk_conf_dao.py
@@ -6,6 +6,7 @@ from __future__ import annotations
 from typing import NamedTuple
 from collections import defaultdict
 
+from sqlalchemy import bindparam
 from sqlalchemy.orm import joinedload
 from sqlalchemy.sql.expression import (
     and_,
@@ -15,6 +16,7 @@ from sqlalchemy.sql.expression import (
     or_,
     true,
 )
+from sqlalchemy.ext import baked
 from sqlalchemy.types import Integer
 
 from xivo_dao.alchemy.feature_extension import FeatureExtension
@@ -66,22 +68,33 @@ class Member(NamedTuple):
 def find_sccp_general_settings(session):
     rows = session.query(SCCPGeneralSettings).all()
 
-    voicemail_consult_exten = session.query(
-        literal('vmexten').label('option_name'),
-        FeatureExtension.exten.label('option_value'),
-    ).filter(and_(
-        FeatureExtension.feature == 'vmusermsg',
-    )).first()
+    voicemail_consult_exten = (
+        session.query(
+            literal('vmexten').label('option_name'),
+            FeatureExtension.exten.label('option_value'),
+        )
+        .filter(
+            and_(
+                FeatureExtension.feature == 'vmusermsg',
+            )
+        )
+        .first()
+    )
 
-    res = [{
-        'option_name': row.option_name,
-        'option_value': row.option_value,
-    } for row in rows]
+    res = [
+        {
+            'option_name': row.option_name,
+            'option_value': row.option_value,
+        }
+        for row in rows
+    ]
 
-    res.append({
-        'option_name': voicemail_consult_exten.option_name,
-        'option_value': voicemail_consult_exten.option_value
-    })
+    res.append(
+        {
+            'option_name': voicemail_consult_exten.option_name,
+            'option_value': voicemail_consult_exten.option_value,
+        }
+    )
 
     return res
 
@@ -130,32 +143,53 @@ def find_sccp_line_settings(session):
 
         return line
 
-    rows = session.query(
-        SCCPLine.id,
-        SCCPLine.tenant_uuid,
-        SCCPLine.name,
-        SCCPLine.cid_name,
-        SCCPLine.cid_num,
-        SCCPLine.allow,
-        SCCPLine.disallow,
-        UserFeatures.language,
-        UserLine.user_id,
-        LineFeatures.context,
-        Extension.exten,
-        UserFeatures.uuid,
-        UserFeatures.enableonlinerec,
-    ).join(LineFeatures, and_(
-        LineFeatures.endpoint_sccp_id == SCCPLine.id,
-    )).join(
-        UserLine, UserLine.line_id == LineFeatures.id,
-    ).join(UserFeatures, and_(
-        UserFeatures.id == UserLine.user_id, UserLine.main_user.is_(True),
-    )).join(LineExtension, and_(
-        LineFeatures.id == LineExtension.line_id,
-        LineExtension.main_extension.is_(True),
-    )).join(
-        Extension, LineExtension.extension_id == Extension.id,
-    ).filter(LineFeatures.commented == 0).all()
+    rows = (
+        session.query(
+            SCCPLine.id,
+            SCCPLine.tenant_uuid,
+            SCCPLine.name,
+            SCCPLine.cid_name,
+            SCCPLine.cid_num,
+            SCCPLine.allow,
+            SCCPLine.disallow,
+            UserFeatures.language,
+            UserLine.user_id,
+            LineFeatures.context,
+            Extension.exten,
+            UserFeatures.uuid,
+            UserFeatures.enableonlinerec,
+        )
+        .join(
+            LineFeatures,
+            and_(
+                LineFeatures.endpoint_sccp_id == SCCPLine.id,
+            ),
+        )
+        .join(
+            UserLine,
+            UserLine.line_id == LineFeatures.id,
+        )
+        .join(
+            UserFeatures,
+            and_(
+                UserFeatures.id == UserLine.user_id,
+                UserLine.main_user.is_(True),
+            ),
+        )
+        .join(
+            LineExtension,
+            and_(
+                LineFeatures.id == LineExtension.line_id,
+                LineExtension.main_extension.is_(True),
+            ),
+        )
+        .join(
+            Extension,
+            LineExtension.extension_id == Extension.id,
+        )
+        .filter(LineFeatures.commented == 0)
+        .all()
+    )
 
     for row in rows:
         yield line_config(*row)
@@ -163,20 +197,36 @@ def find_sccp_line_settings(session):
 
 @daosession
 def find_sccp_device_settings(session):
-    query = session.query(
-        SCCPDevice,
-        Voicemail.mailbox,
-    ).outerjoin(
-        SCCPLine, SCCPLine.name == SCCPDevice.line,
-    ).outerjoin(LineFeatures, and_(
-        LineFeatures.endpoint_sccp_id == SCCPLine.id,
-    )).outerjoin(UserLine, and_(
-        UserLine.line_id == LineFeatures.id,
-        UserLine.main_user.is_(True),
-    )).outerjoin(
-        UserFeatures, UserFeatures.id == UserLine.user_id,
-    ).outerjoin(
-        Voicemail, Voicemail.uniqueid == UserFeatures.voicemailid,
+    query = (
+        session.query(
+            SCCPDevice,
+            Voicemail.mailbox,
+        )
+        .outerjoin(
+            SCCPLine,
+            SCCPLine.name == SCCPDevice.line,
+        )
+        .outerjoin(
+            LineFeatures,
+            and_(
+                LineFeatures.endpoint_sccp_id == SCCPLine.id,
+            ),
+        )
+        .outerjoin(
+            UserLine,
+            and_(
+                UserLine.line_id == LineFeatures.id,
+                UserLine.main_user.is_(True),
+            ),
+        )
+        .outerjoin(
+            UserFeatures,
+            UserFeatures.id == UserLine.user_id,
+        )
+        .outerjoin(
+            Voicemail,
+            Voicemail.uniqueid == UserFeatures.voicemailid,
+        )
     )
 
     devices = []
@@ -191,55 +241,83 @@ def find_sccp_device_settings(session):
 @daosession
 def find_sccp_speeddial_settings(session):
     invalid_chars = '\n\r\t;'
-    query = session.query(
-        FuncKeyMapping.position.label('fknum'),
-        func.translate(FuncKeyMapping.label, invalid_chars, '').label('label'),
-        cast(FuncKeyMapping.blf, Integer).label('supervision'),
-        func.translate(FuncKeyDestCustom.exten, invalid_chars, '').label('exten'),
-        UserFeatures.id.label('user_id'),
-        SCCPDevice.device.label('device'),
-    ).join(
-        UserFeatures,
-        FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
-    ).join(
-        FuncKeyDestCustom,
-        FuncKeyDestCustom.func_key_id == FuncKeyMapping.func_key_id,
-    ).join(UserLine, and_(
-        UserLine.user_id == UserFeatures.id,
-        UserLine.main_user.is_(True),
-    )).join(
-        LineFeatures, UserLine.line_id == LineFeatures.id,
-    ).join(SCCPLine, and_(
-        LineFeatures.endpoint_sccp_id == SCCPLine.id,
-    )).join(
-        SCCPDevice, SCCPLine.name == SCCPDevice.line,
-    ).filter(LineFeatures.commented == 0)
-
-    return [{
-        'exten': row.exten,
-        'fknum': row.fknum,
-        'label': row.label,
-        'supervision': row.supervision,
-        'user_id': row.user_id,
-        'device': row.device,
-    } for row in query]
+    query = (
+        session.query(
+            FuncKeyMapping.position.label('fknum'),
+            func.translate(FuncKeyMapping.label, invalid_chars, '').label('label'),
+            cast(FuncKeyMapping.blf, Integer).label('supervision'),
+            func.translate(FuncKeyDestCustom.exten, invalid_chars, '').label('exten'),
+            UserFeatures.id.label('user_id'),
+            SCCPDevice.device.label('device'),
+        )
+        .join(
+            UserFeatures,
+            FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
+        )
+        .join(
+            FuncKeyDestCustom,
+            FuncKeyDestCustom.func_key_id == FuncKeyMapping.func_key_id,
+        )
+        .join(
+            UserLine,
+            and_(
+                UserLine.user_id == UserFeatures.id,
+                UserLine.main_user.is_(True),
+            ),
+        )
+        .join(
+            LineFeatures,
+            UserLine.line_id == LineFeatures.id,
+        )
+        .join(
+            SCCPLine,
+            and_(
+                LineFeatures.endpoint_sccp_id == SCCPLine.id,
+            ),
+        )
+        .join(
+            SCCPDevice,
+            SCCPLine.name == SCCPDevice.line,
+        )
+        .filter(LineFeatures.commented == 0)
+    )
+
+    return [
+        {
+            'exten': row.exten,
+            'fknum': row.fknum,
+            'label': row.label,
+            'supervision': row.supervision,
+            'user_id': row.user_id,
+            'device': row.device,
+        }
+        for row in query
+    ]
 
 
 @daosession
 def find_features_settings(session):
-    rows = session.query(
-        Features.category, Features.var_name, Features.var_val,
-    ).filter(and_(
-        Features.commented == 0,
-        or_(
+    rows = (
+        session.query(
+            Features.category,
+            Features.var_name,
+            Features.var_val,
+        )
+        .filter(
             and_(
-                Features.category == 'general',
-                ~Features.var_name.in_(PARKING_OPTIONS)
-            ),
-            Features.category == 'featuremap',
-            Features.category == 'applicationmap',
+                Features.commented == 0,
+                or_(
+                    and_(
+                        Features.category == 'general',
+                        ~Features.var_name.in_(PARKING_OPTIONS),
+                    ),
+                    Features.category == 'featuremap',
+                    Features.category == 'applicationmap',
+                ),
+            )
         )
-    )).all()
+        .all()
+    )
 
     general_options = []
     featuremap_options = []
@@ -265,13 +343,20 @@ def find_features_settings(session):
 
 @daosession
 def find_parking_settings(session):
-    rows = session.query(
-        Features.var_name, Features.var_val,
-    ).filter(and_(
-        Features.commented == 0,
-        Features.category == 'general',
-        Features.var_name.in_(PARKING_OPTIONS),
-    )).all()
+    rows = (
+        session.query(
+            Features.var_name,
+            Features.var_val,
+        )
+        .filter(
+            and_(
+                Features.commented == 0,
+                Features.category == 'general',
+                Features.var_name.in_(PARKING_OPTIONS),
+            )
+        )
+        .all()
+    )
 
     general_options = []
     default_parking_lot_options = []
@@ -284,10 +369,12 @@ def find_parking_settings(session):
 
     return {
         'general_options': general_options,
-        'parking_lots': [{
-            'name': 'default',
-            'options': default_parking_lot_options,
-        }],
+        'parking_lots': [
+            {
+                'name': 'default',
+                'options': default_parking_lot_options,
+            }
+        ],
     }
 
 
@@ -310,40 +397,68 @@ def find_exten_conferences_settings(session, context_name):
 
 @daosession
 def find_exten_xivofeatures_setting(session):
-    rows = session.query(FeatureExtension).filter(
-        FeatureExtension.enabled == true(),
-    ).order_by('exten').all()
+    rows = (
+        session.query(FeatureExtension)
+        .filter(
+            FeatureExtension.enabled == true(),
+        )
+        .order_by('exten')
+        .all()
+    )
 
     return [row.todict() for row in rows]
 
 
 @daosession
 def find_extenfeatures_settings(session, features):
-    query = session.query(FeatureExtension).filter(and_(
-        FeatureExtension.feature.in_(features),
-    )).order_by('exten')
+    query = (
+        session.query(FeatureExtension)
+        .filter(
+            and_(
+                FeatureExtension.feature.in_(features),
+            )
+        )
+        .order_by('exten')
+    )
 
     return query.all()
 
 
+exten_settings_bakery = baked.bakery()
+exten_settings_query = exten_settings_bakery(
+    lambda s: s.query(
+        Extension,
+    )
+    .outerjoin(
+        LineExtension,
+        Extension.id == LineExtension.extension_id,
+    )
+    .outerjoin(
+        LineFeatures,
+        LineFeatures.id == LineExtension.line_id,
+    )
+    .filter(
+        and_(
+            Extension.commented == 0,
+            Extension.typeval != '0',
+            Extension.type != 'parking',
+            or_(
+                LineExtension.line_id.is_(None),
+                LineFeatures.commented == 0,
+            ),
+        )
+    )
+    .order_by('exten')
+)
+exten_settings_query += lambda q: q.filter(Extension.context == bindparam('context'))
+
+
 @daosession
 def find_exten_settings(session, context_name):
-    rows = session.query(Extension).outerjoin(
-        LineExtension, Extension.id == LineExtension.extension_id,
-    ).outerjoin(
-        LineFeatures, LineFeatures.id == LineExtension.line_id,
-    ).filter(and_(
-        Extension.context == context_name,
-        Extension.commented == 0,
-        Extension.typeval != '0',
-        Extension.type != 'parking',
-        or_(
-            LineExtension.line_id.is_(None),
-            LineFeatures.commented == 0,
-        ),
-    )).order_by('exten').all()
-
-    return [dict(tenant_uuid=row.context_rel.tenant_uuid, **row.todict()) for row in rows]
+    rows = exten_settings_query(session).params(context=context_name).all()
+    return [
+        dict(tenant_uuid=row.context_rel.tenant_uuid, **row.todict()) for row in rows
+    ]
 
 
 @daosession
@@ -353,12 +468,18 @@ def find_context_settings(session):
     return [row.todict() for row in rows]
 
 
+context_include_bakery = baked.bakery()
+context_include_query = context_include_bakery(
+    lambda s: s.query(ContextInclude).order_by('priority')
+)
+context_include_query += lambda q: q.filter(
+    ContextInclude.context == bindparam('context')
+)
+
+
 @daosession
 def find_contextincludes_settings(session, context_name):
-    rows = session.query(ContextInclude).filter(
-        ContextInclude.context == context_name
-    ).order_by('priority').all()
-
+    rows = context_include_query(session).params(context=context_name).all()
     return [row.todict() for row in rows]
 
 
@@ -375,17 +496,18 @@ def find_voicemail_general_settings(session):
 
     res = []
     for row in rows:
-        res.append({
-            'category': row.category,
-            'var_name': row.var_name,
-            'var_val': row.var_val,
-        })
+        res.append(
+            {
+                'category': row.category,
+                'var_name': row.var_name,
+                'var_val': row.var_val,
+            }
+        )
 
     return res
 
 
 class _SIPEndpointResolver:
-
     def __init__(self, endpoint_config, parents):
         self._endpoint_config = endpoint_config
         self._base_config = self._endpoint_to_dict(self._endpoint_config)
@@ -434,20 +556,22 @@ class _SIPEndpointResolver:
 
     def resolve(self):
         if self._body is None:
-            self._body = self._canonicalize_config({
-                'uuid': self._endpoint_config.uuid,
-                'name': self._endpoint_config.name,
-                'label': self._endpoint_config.label,
-                'template': self._endpoint_config.template,
-                'asterisk_id': self._endpoint_config.asterisk_id,
-                'aor_section_options': self.get_aor_section(),
-                'auth_section_options': self.get_auth_section(),
-                'endpoint_section_options': self.get_endpoint_section(),
-                'identify_section_options': self.get_identify_section(),
-                'outbound_auth_section_options': self.get_outbound_auth_section(),
-                'registration_section_options': self.get_registration_section(),
-                'registration_outbound_auth_section_options': self.get_registration_outbound_auth_section(),
-            })
+            self._body = self._canonicalize_config(
+                {
+                    'uuid': self._endpoint_config.uuid,
+                    'name': self._endpoint_config.name,
+                    'label': self._endpoint_config.label,
+                    'template': self._endpoint_config.template,
+                    'asterisk_id': self._endpoint_config.asterisk_id,
+                    'aor_section_options': self.get_aor_section(),
+                    'auth_section_options': self.get_auth_section(),
+                    'endpoint_section_options': self.get_endpoint_section(),
+                    'identify_section_options': self.get_identify_section(),
+                    'outbound_auth_section_options': self.get_outbound_auth_section(),
+                    'registration_section_options': self.get_registration_section(),
+                    'registration_outbound_auth_section_options': self.get_registration_outbound_auth_section(),
+                }
+            )
 
         return self._body
 
@@ -503,7 +627,9 @@ class _SIPEndpointResolver:
             options.append(('type', 'endpoint'))
 
             if self.get_outbound_auth_section():
-                options.append(('outbound_auth', f'outbound_auth_{self._endpoint_config.name}'))
+                options.append(
+                    ('outbound_auth', f'outbound_auth_{self._endpoint_config.name}')
+                )
 
         return options
 
@@ -526,7 +652,9 @@ class _SIPEndpointResolver:
             options.append(('type', 'registration'))
             options.append(('endpoint', self._endpoint_config.name))
             if self.get_registration_outbound_auth_section():
-                options.append(('outbound_auth', f'auth_reg_{self._endpoint_config.name}'))
+                options.append(
+                    ('outbound_auth', f'auth_reg_{self._endpoint_config.name}')
+                )
         return options
 
     def _build_registration_outbound_auth_section(self):
@@ -583,9 +711,13 @@ class _SIPEndpointResolver:
             'auth_section_options': list(endpoint.auth_section_options),
             'endpoint_section_options': list(endpoint.endpoint_section_options),
             'registration_section_options': list(endpoint.registration_section_options),
-            'registration_outbound_auth_section_options': list(endpoint.registration_outbound_auth_section_options),
+            'registration_outbound_auth_section_options': list(
+                endpoint.registration_outbound_auth_section_options
+            ),
             'identify_section_options': list(endpoint.identify_section_options),
-            'outbound_auth_section_options': list(endpoint.outbound_auth_section_options),
+            'outbound_auth_section_options': list(
+                endpoint.outbound_auth_section_options
+            ),
             'template': endpoint.template,
             'asterisk_id': endpoint.asterisk_id,
         }
@@ -669,15 +801,21 @@ class _EndpointSIPLineResolver(_SIPEndpointResolver):
 
         if self._line.extensions:
             for extension in self._line.extensions:
-                options.append(('set_var', f'PICKUPMARK={extension.exten}%{extension.context}'))
+                options.append(
+                    ('set_var', f'PICKUPMARK={extension.exten}%{extension.context}')
+                )
                 break
 
         pickup_groups = self._pickup_members.get(self._endpoint_config.uuid, {})
-        named_pickup_groups = ','.join(str(id) for id in pickup_groups.get('pickupgroup', []))
+        named_pickup_groups = ','.join(
+            str(id) for id in pickup_groups.get('pickupgroup', [])
+        )
         if named_pickup_groups:
             options.append(('named_pickup_group', named_pickup_groups))
 
-        named_call_groups = ','.join(str(id) for id in pickup_groups.get('callgroup', []))
+        named_call_groups = ','.join(
+            str(id) for id in pickup_groups.get('callgroup', [])
+        )
         if named_call_groups:
             options.append(('named_call_group', named_call_groups))
 
@@ -705,98 +843,156 @@ def merge_endpoints_and_template(items, Klass, endpoint_field, *args):
     for item in items:
         add_endpoint_configuration(getattr(item, endpoint_field), item)
 
-    endpoint_configs = (config for config in resolved_configs.values() if not config.template)
+    endpoint_configs = (
+        config for config in resolved_configs.values() if not config.template
+    )
     return [config.resolve() for config in endpoint_configs]
 
 
 @daosession
 def find_sip_meeting_guests_settings(session):
-    query = session.query(
-        Meeting,
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('template_relations').joinedload('parent'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('_aor_section'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('_auth_section'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('_endpoint_section'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('_registration_section'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('_registration_outbound_auth_section'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('_identify_section'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('_outbound_auth_section'),
-    ).options(
-        joinedload('guest_endpoint_sip').joinedload('transport'),
-    ).filter(Meeting.guest_endpoint_sip_uuid.isnot(None))
-
-    return merge_endpoints_and_template(query.all(), _EndpointSIPMeetingResolver, 'guest_endpoint_sip')
+    query = (
+        session.query(
+            Meeting,
+        )
+        .options(
+            joinedload('guest_endpoint_sip')
+            .joinedload('template_relations')
+            .joinedload('parent'),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload('_aor_section'),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload('_auth_section'),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload('_endpoint_section'),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload('_registration_section'),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload(
+                '_registration_outbound_auth_section'
+            ),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload('_identify_section'),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload('_outbound_auth_section'),
+        )
+        .options(
+            joinedload('guest_endpoint_sip').joinedload('transport'),
+        )
+        .filter(Meeting.guest_endpoint_sip_uuid.isnot(None))
+    )
+
+    return merge_endpoints_and_template(
+        query.all(), _EndpointSIPMeetingResolver, 'guest_endpoint_sip'
+    )
 
 
 @daosession
 def find_sip_user_settings(session):
     pickup_members = find_pickup_members('sip')
-    query = session.query(
-        LineFeatures,
-    ).options(
-        joinedload('endpoint_sip').joinedload('template_relations').joinedload('parent'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_aor_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_auth_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_endpoint_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_registration_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_registration_outbound_auth_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_identify_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_outbound_auth_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('transport'),
-    ).options(
-        joinedload('user_lines').joinedload('user').joinedload('voicemail'),
-    ).options(
-        joinedload('line_extensions').joinedload('extension'),
-    ).filter(
-        LineFeatures.endpoint_sip_uuid.isnot(None),
+    query = (
+        session.query(
+            LineFeatures,
+        )
+        .options(
+            joinedload('endpoint_sip')
+            .joinedload('template_relations')
+            .joinedload('parent'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_aor_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_auth_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_endpoint_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_registration_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload(
+                '_registration_outbound_auth_section'
+            ),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_identify_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_outbound_auth_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('transport'),
+        )
+        .options(
+            joinedload('user_lines').joinedload('user').joinedload('voicemail'),
+        )
+        .options(
+            joinedload('line_extensions').joinedload('extension'),
+        )
+        .filter(
+            LineFeatures.endpoint_sip_uuid.isnot(None),
+        )
     )
 
-    return merge_endpoints_and_template(query.all(), _EndpointSIPLineResolver, 'endpoint_sip', pickup_members)
+    return merge_endpoints_and_template(
+        query.all(), _EndpointSIPLineResolver, 'endpoint_sip', pickup_members
+    )
 
 
 @daosession
 def find_sip_trunk_settings(session):
-    query = session.query(
-        TrunkFeatures,
-    ).options(
-        joinedload('endpoint_sip').joinedload('template_relations').joinedload('parent'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_aor_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_auth_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_endpoint_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_registration_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_registration_outbound_auth_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_identify_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('_outbound_auth_section'),
-    ).options(
-        joinedload('endpoint_sip').joinedload('transport'),
-    ).filter(
-        TrunkFeatures.endpoint_sip_uuid.isnot(None),
+    query = (
+        session.query(
+            TrunkFeatures,
+        )
+        .options(
+            joinedload('endpoint_sip')
+            .joinedload('template_relations')
+            .joinedload('parent'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_aor_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_auth_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_endpoint_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_registration_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload(
+                '_registration_outbound_auth_section'
+            ),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_identify_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('_outbound_auth_section'),
+        )
+        .options(
+            joinedload('endpoint_sip').joinedload('transport'),
+        )
+        .filter(
+            TrunkFeatures.endpoint_sip_uuid.isnot(None),
+        )
     )
 
-    return merge_endpoints_and_template(query.all(), _EndpointSIPTrunkResolver, 'endpoint_sip')
+    return merge_endpoints_and_template(
+        query.all(), _EndpointSIPTrunkResolver, 'endpoint_sip'
+    )
 
 
 @daosession
@@ -826,15 +1022,20 @@ def find_pickup_members(session, protocol):
 
     add_member = _add_member
 
-    base_query = session.query(
-        PickupMember.category,
-        Pickup.id,
-        LineFeatures.endpoint_sip_uuid,
-        LineFeatures.endpoint_sccp_id,
-        LineFeatures.endpoint_custom_id,
-    ).join(
-        Pickup, Pickup.id == PickupMember.pickupid,
-    ).filter(Pickup.commented == 0)
+    base_query = (
+        session.query(
+            PickupMember.category,
+            Pickup.id,
+            LineFeatures.endpoint_sip_uuid,
+            LineFeatures.endpoint_sccp_id,
+            LineFeatures.endpoint_custom_id,
+        )
+        .join(
+            Pickup,
+            Pickup.id == PickupMember.pickupid,
+        )
+        .filter(Pickup.commented == 0)
+    )
 
     if protocol == 'sip':
         base_query = base_query.filter(LineFeatures.endpoint_sip_uuid.isnot(None))
@@ -843,45 +1044,71 @@ def find_pickup_members(session, protocol):
     elif protocol == 'custom':
         base_query = base_query.filter(LineFeatures.endpoint_custom_id.isnot(None))
 
-    users = base_query.join(
-        UserLine, UserLine.user_id == PickupMember.memberid,
-    ).join(
-        LineFeatures, LineFeatures.id == UserLine.line_id,
-    ).filter(
-        PickupMember.membertype == 'user',
+    users = (
+        base_query.join(
+            UserLine,
+            UserLine.user_id == PickupMember.memberid,
+        )
+        .join(
+            LineFeatures,
+            LineFeatures.id == UserLine.line_id,
+        )
+        .filter(
+            PickupMember.membertype == 'user',
+        )
     )
 
-    groups = base_query.join(
-        GroupFeatures, GroupFeatures.id == PickupMember.memberid,
-    ).join(
-        QueueMember, QueueMember.queue_name == GroupFeatures.name,
-    ).join(
-        UserLine, UserLine.user_id == QueueMember.userid,
-    ).join(
-        LineFeatures, LineFeatures.id == UserLine.line_id,
-    ).filter(
-        and_(
-            PickupMember.membertype == 'group',
-            QueueMember.usertype == 'user',
-            UserLine.main_user == True,  # noqa
-            UserLine.main_line == True,  # noqa
+    groups = (
+        base_query.join(
+            GroupFeatures,
+            GroupFeatures.id == PickupMember.memberid,
+        )
+        .join(
+            QueueMember,
+            QueueMember.queue_name == GroupFeatures.name,
+        )
+        .join(
+            UserLine,
+            UserLine.user_id == QueueMember.userid,
+        )
+        .join(
+            LineFeatures,
+            LineFeatures.id == UserLine.line_id,
+        )
+        .filter(
+            and_(
+                PickupMember.membertype == 'group',
+                QueueMember.usertype == 'user',
+                UserLine.main_user == True,  # noqa
+                UserLine.main_line == True,  # noqa
+            )
         )
     )
 
-    queues = base_query.join(
-        QueueFeatures, QueueFeatures.id == PickupMember.memberid,
-    ).join(
-        QueueMember, QueueMember.queue_name == QueueFeatures.name,
-    ).join(
-        UserLine, UserLine.user_id == QueueMember.userid,
-    ).join(
-        LineFeatures, LineFeatures.id == UserLine.line_id,
-    ).filter(
-        and_(
-            PickupMember.membertype == 'queue',
-            QueueMember.usertype == 'user',
-            UserLine.main_user == True,  # noqa
-            UserLine.main_line == True,  # noqa
+    queues = (
+        base_query.join(
+            QueueFeatures,
+            QueueFeatures.id == PickupMember.memberid,
+        )
+        .join(
+            QueueMember,
+            QueueMember.queue_name == QueueFeatures.name,
+        )
+        .join(
+            UserLine,
+            UserLine.user_id == QueueMember.userid,
+        )
+        .join(
+            LineFeatures,
+            LineFeatures.id == UserLine.line_id,
+        )
+        .filter(
+            and_(
+                PickupMember.membertype == 'queue',
+                QueueMember.usertype == 'user',
+                UserLine.main_user == True,  # noqa
+                UserLine.main_line == True,  # noqa
+            )
         )
     )
 
@@ -897,20 +1124,28 @@ def find_iax_general_settings(session):
 
     res = []
     for row in rows:
-        res.append({
-            'var_name': row.var_name,
-            'var_val': row.var_val,
-        })
+        res.append(
+            {
+                'var_name': row.var_name,
+                'var_val': row.var_val,
+            }
+        )
 
     return res
 
 
 @daosession
 def find_iax_trunk_settings(session):
-    rows = session.query(UserIAX).filter(and_(
-        UserIAX.commented == 0,
-        UserIAX.category == 'trunk',
-    )).all()
+    rows = (
+        session.query(UserIAX)
+        .filter(
+            and_(
+                UserIAX.commented == 0,
+                UserIAX.category == 'trunk',
+            )
+        )
+        .all()
+    )
 
     return rows
 
@@ -924,23 +1159,29 @@ def find_iax_calllimits_settings(session):
 
 @daosession
 def find_queue_general_settings(session):
-    rows = session.query(StaticQueue).filter(and_(
-        StaticQueue.commented == 0,
-        StaticQueue.category == 'general',
-    )).all()
+    rows = (
+        session.query(StaticQueue)
+        .filter(
+            and_(
+                StaticQueue.commented == 0,
+                StaticQueue.category == 'general',
+            )
+        )
+        .all()
+    )
 
     return [row.todict() for row in rows]
 
 
 @daosession
 def find_queue_settings(session):
-    rows = session.query(
-        Queue
-    ).options(
-        joinedload('groupfeatures')
-    ).options(
-        joinedload('queuefeatures')
-    ).filter(Queue.commented == 0).all()
+    rows = (
+        session.query(Queue)
+        .options(joinedload('groupfeatures'))
+        .options(joinedload('queuefeatures'))
+        .filter(Queue.commented == 0)
+        .all()
+    )
 
     result = []
     for row in rows:
@@ -966,19 +1207,25 @@ def find_queue_penalty_settings(session):
 
 @daosession
 def find_queue_members_settings(session, queue_name):
-    user_members = session.query(
-        QueueMember.category,
-        QueueMember.penalty,
-        QueueMember.position,
-        QueueMember.interface,
-        UserFeatures.uuid,
-    ).outerjoin(
-        UserFeatures, QueueMember.userid == UserFeatures.id
-    ).filter(and_(
-        QueueMember.commented == 0,
-        QueueMember.queue_name == queue_name,
-        QueueMember.usertype == 'user',
-    )).order_by(QueueMember.position).all()
+    user_members = (
+        session.query(
+            QueueMember.category,
+            QueueMember.penalty,
+            QueueMember.position,
+            QueueMember.interface,
+            UserFeatures.uuid,
+        )
+        .outerjoin(UserFeatures, QueueMember.userid == UserFeatures.id)
+        .filter(
+            and_(
+                QueueMember.commented == 0,
+                QueueMember.queue_name == queue_name,
+                QueueMember.usertype == 'user',
+            )
+        )
+        .order_by(QueueMember.position)
+        .all()
+    )
 
     def is_user_in_group(row):
         return row.category == 'group' and row.uuid is not None
@@ -1005,45 +1252,60 @@ def find_queue_members_settings(session, queue_name):
 
 @daosession
 def find_agent_queue_skills_settings(session):
-    rows = session.query(
-        AgentFeatures.id,
-        QueueSkill.name,
-        AgentQueueSkill.weight,
-    ).filter(and_(
-        AgentQueueSkill.agentid == AgentFeatures.id,
-        AgentQueueSkill.skillid == QueueSkill.id,
-    )).order_by(AgentFeatures.id).all()
+    rows = (
+        session.query(
+            AgentFeatures.id,
+            QueueSkill.name,
+            AgentQueueSkill.weight,
+        )
+        .filter(
+            and_(
+                AgentQueueSkill.agentid == AgentFeatures.id,
+                AgentQueueSkill.skillid == QueueSkill.id,
+            )
+        )
+        .order_by(AgentFeatures.id)
+        .all()
+    )
 
     res = []
     for id_, name, weight in rows:
-        res.append({
-            'id': id_,
-            'name': name,
-            'weight': weight,
-        })
+        res.append(
+            {
+                'id': id_,
+                'name': name,
+                'weight': weight,
+            }
+        )
 
     return res
 
 
 @daosession
 def find_queue_penalties_settings(session):
-    rows = session.query(
-        QueuePenalty.name,
-        QueuePenaltyChange
-    ).filter(and_(
-        QueuePenalty.id == QueuePenaltyChange.queuepenalty_id,
-        QueuePenalty.commented == 0,
-    )).order_by(QueuePenalty.name).all()
+    rows = (
+        session.query(QueuePenalty.name, QueuePenaltyChange)
+        .filter(
+            and_(
+                QueuePenalty.id == QueuePenaltyChange.queuepenalty_id,
+                QueuePenalty.commented == 0,
+            )
+        )
+        .order_by(QueuePenalty.name)
+        .all()
+    )
 
     res = []
     for name, penalty_change in rows:
-        res.append({
-            'name': name,
-            'seconds': penalty_change.seconds,
-            'maxp_sign': penalty_change.maxp_sign,
-            'maxp_value': penalty_change.maxp_value,
-            'minp_sign': penalty_change.minp_sign,
-            'minp_value': penalty_change.minp_value,
-        })
+        res.append(
+            {
+                'name': name,
+                'seconds': penalty_change.seconds,
+                'maxp_sign': penalty_change.maxp_sign,
+                'maxp_value': penalty_change.maxp_value,
+                'minp_sign': penalty_change.minp_sign,
+                'minp_value': penalty_change.minp_value,
+            }
+        )
 
     return res
diff --git a/xivo_dao/resources/func_key/hint_dao.py b/xivo_dao/resources/func_key/hint_dao.py
index 26e743a9..1b83fe55 100644
--- a/xivo_dao/resources/func_key/hint_dao.py
+++ b/xivo_dao/resources/func_key/hint_dao.py
@@ -1,8 +1,11 @@
 # Copyright 2014-2023 The Wazo Authors  (see the AUTHORS file)
 # SPDX-License-Identifier: GPL-3.0-or-later
 
+from collections import defaultdict
+
 from sqlalchemy import (
     and_,
+    bindparam,
     Integer,
     Unicode,
     literal_column,
@@ -12,6 +15,7 @@ from sqlalchemy.orm import (
     aliased,
     joinedload,
 )
+from sqlalchemy.ext import baked
 from sqlalchemy.sql.expression import true
 
 from xivo.xivo_helpers import clean_extension
@@ -39,46 +43,366 @@ from xivo_dao.alchemy.userfeatures import UserFeatures
 from xivo_dao.helpers.db_manager import daosession
 from xivo_dao.resources.func_key.model import Hint
 
+user_extension = aliased(Extension)
 
-def _find_extenfeatures(session, feature):
-    return (
-        session.query(FeatureExtension.exten)
-        .filter(
-            FeatureExtension.feature == feature,
+agent_hints_bakery = baked.bakery()
+agent_hints_query = agent_hints_bakery(
+    lambda s: s.query(
+        sql.cast(FuncKeyDestAgent.agent_id, Unicode).label('argument'),
+        UserFeatures.id.label('user_id'),
+        FeatureExtension.exten.label('feature_extension'),
+        user_extension.context,
+    )
+    .join(
+        FeatureExtension,
+        FeatureExtension.uuid == FuncKeyDestAgent.feature_extension_uuid,
+    )
+    .join(
+        FuncKeyMapping,
+        FuncKeyDestAgent.func_key_id == FuncKeyMapping.func_key_id,
+    )
+    .filter(
+        FeatureExtension.enabled == true(),
+    )
+    .join(
+        UserFeatures,
+        FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
+    )
+    .join(
+        UserLine,
+        UserFeatures.id == UserLine.user_id,
+    )
+    .join(
+        LineExtension,
+        LineExtension.line_id == UserLine.line_id,
+    )
+    .join(
+        user_extension,
+        LineExtension.extension_id == user_extension.id,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            UserLine.main_line.is_(True),
+            LineExtension.main_extension.is_(True),
+            FuncKeyMapping.blf.is_(True),
+        )
+    )
+)
+
+bsfilter_hints_bakery = baked.bakery()
+bsfilter_hints_query = bsfilter_hints_bakery(
+    lambda s: s.query(
+        sql.cast(FuncKeyDestBSFilter.filtermember_id, Unicode).label('argument'),
+        Extension.context,
+    )
+    .join(
+        Callfiltermember,
+        Callfiltermember.id == FuncKeyDestBSFilter.filtermember_id,
+    )
+    .join(
+        Callfilter,
+        Callfilter.id == Callfiltermember.callfilterid,
+    )
+    .join(
+        UserFeatures,
+        sql.cast(Callfiltermember.typeval, Integer) == UserFeatures.id,
+    )
+    .join(
+        UserLine,
+        UserLine.user_id == UserFeatures.id,
+    )
+    .join(
+        LineExtension,
+        UserLine.line_id == LineExtension.line_id,
+    )
+    .join(
+        Extension,
+        Extension.id == LineExtension.extension_id,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            UserLine.main_line.is_(True),
+            LineExtension.main_extension.is_(True),
+            Extension.commented == 0,
+            Callfilter.commented == 0,
         )
-        .scalar()
     )
+)
+
 
+conference_hints_bakery = baked.bakery()
+conference_hints_query = conference_hints_bakery(
+    lambda s: s.query(
+        Conference.id.label('conference_id'),
+        Extension.exten.label('extension'),
+        Extension.context,
+    )
+    .select_from(Conference)
+    .join(FuncKeyDestConference, FuncKeyDestConference.conference_id == Conference.id)
+    .join(
+        Extension,
+        sql.and_(
+            Extension.type == 'conference',
+            Extension.typeval == sql.cast(Conference.id, Unicode),
+        ),
+    )
+)
 
-def _common_filter(query, context):
-    user_extension = aliased(Extension)
-    return (
-        query.join(
-            UserFeatures,
-            FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
+custom_hints_bakery = baked.bakery()
+custom_hints_query = custom_hints_bakery(
+    lambda s: s.query(
+        FuncKeyDestCustom.exten.label('extension'), user_extension.context
+    )
+    .join(
+        FuncKeyMapping,
+        FuncKeyDestCustom.func_key_id == FuncKeyMapping.func_key_id,
+    )
+    .join(
+        UserFeatures,
+        FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
+    )
+    .join(
+        UserLine,
+        UserFeatures.id == UserLine.user_id,
+    )
+    .join(
+        LineExtension,
+        LineExtension.line_id == UserLine.line_id,
+    )
+    .join(
+        user_extension,
+        LineExtension.extension_id == user_extension.id,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            UserLine.main_line.is_(True),
+            LineExtension.main_extension.is_(True),
+            FuncKeyMapping.blf.is_(True),
         )
-        .join(
-            UserLine,
-            UserFeatures.id == UserLine.user_id,
+    )
+)
+
+forwards_hints_bakery = baked.bakery()
+forwards_hints_query = forwards_hints_bakery(
+    lambda s: s.query(
+        FeatureExtension.exten.label('feature_extension'),
+        UserFeatures.id.label('user_id'),
+        FuncKeyDestForward.number.label('argument'),
+        user_extension.context,
+    )
+    .join(
+        FuncKeyDestForward,
+        FuncKeyDestForward.feature_extension_uuid == FeatureExtension.uuid,
+    )
+    .join(
+        FuncKeyMapping,
+        FuncKeyDestForward.func_key_id == FuncKeyMapping.func_key_id,
+    )
+    .filter(FeatureExtension.enabled == true())
+    .join(
+        UserFeatures,
+        FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
+    )
+    .join(
+        UserLine,
+        UserFeatures.id == UserLine.user_id,
+    )
+    .join(
+        LineExtension,
+        LineExtension.line_id == UserLine.line_id,
+    )
+    .join(
+        user_extension,
+        LineExtension.extension_id == user_extension.id,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            UserLine.main_line.is_(True),
+            LineExtension.main_extension.is_(True),
+            FuncKeyMapping.blf.is_(True),
         )
-        .join(
-            LineExtension,
-            LineExtension.line_id == UserLine.line_id,
+    )
+)
+
+groupmember_hints_bakery = baked.bakery()
+groupmember_hints_query = groupmember_hints_bakery(
+    lambda s: s.query(
+        sql.cast(FuncKeyDestGroupMember.group_id, Unicode).label('argument'),
+        UserFeatures.id.label('user_id'),
+        FeatureExtension.exten.label('feature_extension'),
+        user_extension.context,
+    )
+    .join(
+        FeatureExtension,
+        FeatureExtension.uuid == FuncKeyDestGroupMember.feature_extension_uuid,
+    )
+    .join(
+        FuncKeyMapping,
+        FuncKeyDestGroupMember.func_key_id == FuncKeyMapping.func_key_id,
+    )
+    .filter(
+        FeatureExtension.enabled == true(),
+    )
+    .join(
+        UserFeatures,
+        FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
+    )
+    .join(
+        UserLine,
+        UserFeatures.id == UserLine.user_id,
+    )
+    .join(
+        LineExtension,
+        LineExtension.line_id == UserLine.line_id,
+    )
+    .join(
+        user_extension,
+        LineExtension.extension_id == user_extension.id,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            UserLine.main_line.is_(True),
+            LineExtension.main_extension.is_(True),
+            FuncKeyMapping.blf.is_(True),
         )
-        .join(
-            user_extension,
-            LineExtension.extension_id == user_extension.id,
+    )
+)
+
+user_extensions_bakery = baked.bakery()
+user_extensions_query = user_extensions_bakery(
+    lambda s: s.query(
+        UserFeatures.id.label('user_id'),
+        Extension.exten.label('extension'),
+        Extension.context,
+    )
+    .distinct()
+    .join(
+        UserLine.userfeatures,
+    )
+    .join(
+        LineExtension,
+        UserLine.line_id == LineExtension.line_id,
+    )
+    .join(
+        Extension,
+        LineExtension.extension_id == Extension.id,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            LineExtension.main_extension.is_(True),
+            UserFeatures.enablehint == 1,
         )
-        .filter(
-            and_(
-                user_extension.context == context,
-                UserLine.main_user.is_(True),
-                UserLine.main_line.is_(True),
-                LineExtension.main_extension.is_(True),
-                FuncKeyMapping.blf.is_(True),
-            )
+    )
+)
+
+user_arguments_bakery = baked.bakery()
+user_arguments_query = user_arguments_bakery(
+    lambda s: s.query(
+        UserFeatures.id.label('user_id'),
+        sql.func.string_agg(
+            sql.case(
+                [
+                    (
+                        LineFeatures.endpoint_sip_uuid.isnot(None),
+                        literal_column("'PJSIP/'") + EndpointSIP.name,
+                    ),
+                    (
+                        LineFeatures.endpoint_sccp_id.isnot(None),
+                        literal_column("'SCCP/'") + SCCPLine.name,
+                    ),
+                    (
+                        LineFeatures.endpoint_custom_id.isnot(None),
+                        UserCustom.interface,
+                    ),
+                ]
+            ),
+            literal_column("'&'"),
+        ).label('argument'),
+    )
+    .join(
+        UserLine.userfeatures,
+    )
+    .join(
+        UserLine.linefeatures,
+    )
+    .outerjoin(
+        EndpointSIP,
+    )
+    .outerjoin(
+        SCCPLine,
+    )
+    .outerjoin(
+        UserCustom,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            LineFeatures.commented == 0,
         )
     )
+    .group_by(UserFeatures.id)
+)
+user_arguments_query += lambda q: q.filter(
+    UserFeatures.id.in_(bindparam('user_ids', expanding=True))
+)
+
+service_hints_bakery = baked.bakery()
+service_hints_query = service_hints_bakery(
+    lambda s: s.query(
+        FeatureExtension.exten.label('feature_extension'),
+        UserFeatures.id.label('user_id'),
+        user_extension.context,
+    )
+    .join(
+        FuncKeyDestService,
+        FuncKeyDestService.feature_extension_uuid == FeatureExtension.uuid,
+    )
+    .join(
+        FuncKeyMapping,
+        FuncKeyDestService.func_key_id == FuncKeyMapping.func_key_id,
+    )
+    .filter(FeatureExtension.enabled == true())
+    .join(
+        UserFeatures,
+        FuncKeyMapping.template_id == UserFeatures.func_key_private_template_id,
+    )
+    .join(
+        UserLine,
+        UserFeatures.id == UserLine.user_id,
+    )
+    .join(
+        LineExtension,
+        LineExtension.line_id == UserLine.line_id,
+    )
+    .join(
+        user_extension,
+        LineExtension.extension_id == user_extension.id,
+    )
+    .filter(
+        and_(
+            UserLine.main_user.is_(True),
+            UserLine.main_line.is_(True),
+            LineExtension.main_extension.is_(True),
+            FuncKeyMapping.blf.is_(True),
+        )
+    )
+)
+
+extenfeatures_bakery = baked.bakery()
+extenfeatures_query = extenfeatures_bakery(lambda s: s.query(FeatureExtension.exten))
+extenfeatures_query += lambda q: q.filter(
+    FeatureExtension.feature == bindparam('feature')
+)
+
+
+def _find_extenfeatures(session, feature):
+    return extenfeatures_query(session).params(feature=feature).scalar()
 
 
 @daosession
@@ -94,20 +418,22 @@ def calluser_extension(session):
 
 
 @daosession
-def user_hints(session, context):
-    user_extensions = _list_user_extensions(session, context)
+def user_hints(session):
+    user_extensions = _list_user_extensions(session)
     if not user_extensions:
-        return tuple()
+        return {}
 
     user_arguments = _list_user_arguments(
         session, {item.user_id for item in user_extensions}
     )
-    hints = []
-    for user_id, extension in user_extensions:
+    hints = defaultdict(list)
+    for user_id, extension, context in user_extensions:
         argument = user_arguments.get(user_id)
         if argument:
-            hints.append(Hint(user_id=user_id, extension=extension, argument=argument))
-    return tuple(hints)
+            hints[context].append(
+                Hint(user_id=user_id, extension=extension, argument=argument)
+            )
+    return hints
 
 
 @daosession
@@ -136,290 +462,94 @@ def user_shared_hints(session):
     return hints
 
 
-def _list_user_extensions(session, context):
-    query = (
-        session.query(
-            UserFeatures.id.label('user_id'),
-            Extension.exten.label('extension'),
-        )
-        .distinct()
-        .join(
-            UserLine.userfeatures,
-        )
-        .join(
-            LineExtension,
-            UserLine.line_id == LineExtension.line_id,
-        )
-        .join(
-            Extension,
-            LineExtension.extension_id == Extension.id,
-        )
-        .filter(
-            and_(
-                UserLine.main_user.is_(True),
-                LineExtension.main_extension.is_(True),
-                Extension.context == context,
-                UserFeatures.enablehint == 1,
-            )
-        )
-    )
-    return query.all()
+def _list_user_extensions(session):
+    return user_extensions_query(session).all()
 
 
 def _list_user_arguments(session, user_ids):
-    query = (
-        session.query(
-            UserFeatures.id.label('user_id'),
-            sql.func.string_agg(
-                sql.case(
-                    [
-                        (
-                            LineFeatures.endpoint_sip_uuid.isnot(None),
-                            literal_column("'PJSIP/'") + EndpointSIP.name,
-                        ),
-                        (
-                            LineFeatures.endpoint_sccp_id.isnot(None),
-                            literal_column("'SCCP/'") + SCCPLine.name,
-                        ),
-                        (
-                            LineFeatures.endpoint_custom_id.isnot(None),
-                            UserCustom.interface,
-                        ),
-                    ]
-                ),
-                literal_column("'&'"),
-            ).label('argument'),
-        )
-        .join(
-            UserLine.userfeatures,
-        )
-        .join(
-            UserLine.linefeatures,
-        )
-        .outerjoin(
-            EndpointSIP,
-        )
-        .outerjoin(
-            SCCPLine,
-        )
-        .outerjoin(
-            UserCustom,
-        )
-        .filter(
-            and_(
-                UserFeatures.id.in_(user_ids),
-                UserLine.main_user.is_(True),
-                LineFeatures.commented == 0,
-            )
-        )
-        .group_by(UserFeatures.id)
-    )
-
+    query = user_arguments_query(session).params(user_ids=list(user_ids)).all()
     return {row.user_id: row.argument for row in query}
 
 
 @daosession
-def conference_hints(session, context):
-    query = (
-        session.query(
-            Conference.id.label('conference_id'), Extension.exten.label('extension')
-        )
-        .select_from(Conference)
-        .join(
-            FuncKeyDestConference, FuncKeyDestConference.conference_id == Conference.id
-        )
-        .join(
-            Extension,
-            sql.and_(
-                Extension.type == 'conference',
-                Extension.typeval == sql.cast(Conference.id, Unicode),
-            ),
-        )
-        .filter(Extension.context == context)
-    )
-
-    return tuple(
-        Hint(conference_id=row.conference_id, extension=row.extension)
-        for row in query.all()
-    )
+def conference_hints(session):
+    query = conference_hints_query(session).all()
+    hints = defaultdict(list)
+    for row in query:
+        hint = Hint(conference_id=row.conference_id, extension=row.extension)
+        hints[row.context].append(hint)
+    return hints
 
 
 @daosession
-def service_hints(session, context):
-    query = (
-        session.query(
-            FeatureExtension.exten.label('feature_extension'),
-            UserFeatures.id.label('user_id'),
-        )
-        .join(
-            FuncKeyDestService,
-            FuncKeyDestService.feature_extension_uuid == FeatureExtension.uuid,
-        )
-        .join(
-            FuncKeyMapping,
-            FuncKeyDestService.func_key_id == FuncKeyMapping.func_key_id,
-        )
-        .filter(FeatureExtension.enabled == true())
-    )
-
-    query = _common_filter(query, context)
-
-    return tuple(
-        Hint(user_id=row.user_id, extension=row.feature_extension, argument=None)
-        for row in query
-    )
+def service_hints(session):
+    query = service_hints_query(session).all()
+    hints = defaultdict(list)
+    for row in query:
+        hint = Hint(user_id=row.user_id, extension=row.feature_extension, argument=None)
+        hints[row.context].append(hint)
+    return hints
 
 
 @daosession
-def forward_hints(session, context):
-    query = (
-        session.query(
-            FeatureExtension.exten.label('feature_extension'),
-            UserFeatures.id.label('user_id'),
-            FuncKeyDestForward.number.label('argument'),
-        )
-        .join(
-            FuncKeyDestForward,
-            FuncKeyDestForward.feature_extension_uuid == FeatureExtension.uuid,
-        )
-        .join(
-            FuncKeyMapping,
-            FuncKeyDestForward.func_key_id == FuncKeyMapping.func_key_id,
-        )
-        .filter(FeatureExtension.enabled == true())
-    )
-
-    query = _common_filter(query, context)
-
-    return tuple(
-        Hint(
+def forward_hints(session):
+    query = forwards_hints_query(session).all()
+    hints = defaultdict(list)
+    for row in query:
+        hint = Hint(
             user_id=row.user_id,
             extension=clean_extension(row.feature_extension),
             argument=row.argument,
         )
-        for row in query
-    )
+        hints[row.context].append(hint)
 
+    return hints
 
-@daosession
-def agent_hints(session, context):
-    query = (
-        session.query(
-            sql.cast(FuncKeyDestAgent.agent_id, Unicode).label('argument'),
-            UserFeatures.id.label('user_id'),
-            FeatureExtension.exten.label('feature_extension'),
-        )
-        .join(
-            FeatureExtension,
-            FeatureExtension.uuid == FuncKeyDestAgent.feature_extension_uuid,
-        )
-        .join(
-            FuncKeyMapping,
-            FuncKeyDestAgent.func_key_id == FuncKeyMapping.func_key_id,
-        )
-        .filter(FeatureExtension.enabled == true())
-    )
-
-    query = _common_filter(query, context)
 
-    return tuple(
-        Hint(
+@daosession
+def agent_hints(session):
+    query = agent_hints_query(session).all()
+    hints = defaultdict(list)
+    for row in query:
+        hint = Hint(
             user_id=row.user_id,
             extension=clean_extension(row.feature_extension),
             argument=row.argument,
         )
-        for row in query
-    )
+        hints[row.context].append(hint)
+    return hints
 
 
 @daosession
-def custom_hints(session, context):
-    query = session.query(
-        FuncKeyDestCustom.exten.label('extension'),
-    ).join(
-        FuncKeyMapping,
-        FuncKeyDestCustom.func_key_id == FuncKeyMapping.func_key_id,
-    )
-
-    query = _common_filter(query, context)
-
-    return tuple(Hint(extension=row.extension) for row in query)
+def custom_hints(session):
+    query = custom_hints_query(session).all()
+    hints = defaultdict(list)
+    for row in query:
+        hint = Hint(extension=row.extension)
+        hints[row.context].append(hint)
+    return hints
 
 
 @daosession
-def bsfilter_hints(session, context):
+def bsfilter_hints(session):
     bsfilter_extension = clean_extension(_find_extenfeatures(session, 'bsfilter'))
-
-    query = (
-        session.query(
-            sql.cast(FuncKeyDestBSFilter.filtermember_id, Unicode).label('argument'),
-        )
-        .join(
-            Callfiltermember,
-            Callfiltermember.id == FuncKeyDestBSFilter.filtermember_id,
-        )
-        .join(
-            Callfilter,
-            Callfilter.id == Callfiltermember.callfilterid,
-        )
-        .join(
-            UserFeatures,
-            sql.cast(Callfiltermember.typeval, Integer) == UserFeatures.id,
-        )
-        .join(
-            UserLine,
-            UserLine.user_id == UserFeatures.id,
-        )
-        .join(
-            LineExtension,
-            UserLine.line_id == LineExtension.line_id,
-        )
-        .join(
-            Extension,
-            Extension.id == LineExtension.extension_id,
-        )
-        .filter(
-            and_(
-                UserLine.main_user.is_(True),
-                UserLine.main_line.is_(True),
-                LineExtension.main_extension.is_(True),
-                Extension.commented == 0,
-                Callfilter.commented == 0,
-                Extension.context == context,
-            )
-        )
-    )
-
-    return tuple(
-        Hint(extension=bsfilter_extension, argument=row.argument) for row in query
-    )
+    query = bsfilter_hints_query(session).all()
+    hints = defaultdict(list)
+    for row in query:
+        hint = Hint(extension=bsfilter_extension, argument=row.argument)
+        hints[row.context].append(hint)
+    return hints
 
 
 @daosession
-def groupmember_hints(session, context):
-    query = (
-        session.query(
-            sql.cast(FuncKeyDestGroupMember.group_id, Unicode).label('argument'),
-            UserFeatures.id.label('user_id'),
-            FeatureExtension.exten.label('feature_extension'),
-        )
-        .join(
-            FeatureExtension,
-            FeatureExtension.uuid == FuncKeyDestGroupMember.feature_extension_uuid,
-        )
-        .join(
-            FuncKeyMapping,
-            FuncKeyDestGroupMember.func_key_id == FuncKeyMapping.func_key_id,
-        )
-        .filter(FeatureExtension.enabled == true())
-    )
-    query = _common_filter(query, context)
-
-    return tuple(
-        Hint(
+def groupmember_hints(session):
+    query = groupmember_hints_query(session).all()
+    hints = defaultdict(list)
+    for row in query:
+        hint = Hint(
             user_id=row.user_id,
             extension=clean_extension(row.feature_extension),
             argument=row.argument,
         )
-        for row in query
-    )
+        hints[row.context].append(hint)
+    return hints
diff --git a/xivo_dao/resources/func_key/model.py b/xivo_dao/resources/func_key/model.py
index 81fd0f8a..edd506cc 100644
--- a/xivo_dao/resources/func_key/model.py
+++ b/xivo_dao/resources/func_key/model.py
@@ -22,3 +22,6 @@ class Hint:
 
     def __ne__(self, other):
         return not self == other
+
+    def __repr__(self):
+        return f'Hint(user_id={self.user_id}, conference_id={self.conference_id}, extension={self.extension}, argument={self.argument})'
diff --git a/xivo_dao/resources/func_key/tests/test_hint_dao.py b/xivo_dao/resources/func_key/tests/test_hint_dao.py
index db979244..030b90e6 100644
--- a/xivo_dao/resources/func_key/tests/test_hint_dao.py
+++ b/xivo_dao/resources/func_key/tests/test_hint_dao.py
@@ -3,11 +3,14 @@
 
 from hamcrest import (
     assert_that,
-    contains,
+    contains_exactly,
     contains_inanyorder,
+    has_key,
     has_properties,
+    has_entries,
     empty,
     equal_to,
+    not_,
 )
 
 from xivo_dao.tests.test_dao import DAOTestCase
@@ -60,15 +63,19 @@ class TestHints(DAOTestCase, FuncKeyHelper):
         exten='1000',
         commented=0,
         enablehint=1,
+        context_name=None,
     ):
+        context_name = context_name or self.context.name
         if not endpoint_sip_uuid:
             endpoint_sip_uuid = self.add_endpoint_sip().uuid
         line = self.add_line(
-            context=self.context.name,
+            context=context_name,
             endpoint_sip_uuid=endpoint_sip_uuid,
             commented=commented,
         )
-        user_row = self._add_user_line_extension(line.id, exten, commented, enablehint)
+        user_row = self._add_user_line_extension(
+            line.id, exten, context_name, commented, enablehint
+        )
         self.add_user_destination(user_row.id)
 
         return user_row
@@ -83,7 +90,9 @@ class TestHints(DAOTestCase, FuncKeyHelper):
             endpoint_sccp_id=endpoint_sccp_id,
             commented=commented,
         )
-        user_row = self._add_user_line_extension(line.id, exten, commented, enablehint)
+        user_row = self._add_user_line_extension(
+            line.id, exten, self.context.name, commented, enablehint
+        )
         self.add_user_destination(user_row.id)
 
         return user_row
@@ -103,9 +112,12 @@ class TestHints(DAOTestCase, FuncKeyHelper):
 
         return user_row
 
-    def _add_user_line_extension(self, line_id, exten, commented=0, enablehint=1):
+    def _add_user_line_extension(
+        self, line_id, exten, context_name=None, commented=0, enablehint=1
+    ):
+        context_name = context_name or self.context.name
         user_row = self.add_user(enablehint=enablehint)
-        extension_row = self.add_extension(exten=exten, context=self.context.name)
+        extension_row = self.add_extension(exten=exten, context=context_name)
 
         self.add_user_line(
             user_id=user_row.id,
@@ -132,20 +144,61 @@ class TestHints(DAOTestCase, FuncKeyHelper):
             line_id=line.id, extension_id=extension_id, main_extension=True
         )
 
+    def add_sip_user_line_extension_in_context(self, context_name):
+        endpoint_sip_row = self.add_endpoint_sip(
+            endpoint_section_options=[['context', context_name]],
+        )
+        line = self.add_line(
+            endpoint_sip_uuid=endpoint_sip_row.uuid,
+            context=context_name,
+        )
+        user = self._add_user_line_extension(
+            line_id=line.id, exten='1000', context_name=context_name
+        )
+        return user
+
 
 class TestUserHints(TestHints):
+    def test_given_users_in_different_contexts(self):
+        context_1 = self.add_context()
+        context_2 = self.add_context()
+        context_3 = self.add_context()
+
+        user_1 = self.add_sip_user_line_extension_in_context(context_1.name)
+        user_2 = self.add_sip_user_line_extension_in_context(context_2.name)
+
+        result = hint_dao.user_hints()
+        assert_that(
+            result,
+            has_entries(
+                {
+                    context_1.name: contains_exactly(
+                        has_properties(user_id=user_1.id),
+                    ),
+                    context_2.name: contains_exactly(
+                        has_properties(user_id=user_2.id),
+                    ),
+                }
+            ),
+        )
+        assert_that(result, not_(has_key(context_3.name)))
+
     def test_given_user_with_sip_line_then_returns_user_hint(self):
         endpoint_sip_row = self.add_endpoint_sip(name='abcdef')
         user_row = self.add_user_sip_and_func_key(endpoint_sip_row.uuid)
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains(
-                has_properties(
-                    user_id=user_row.id,
-                    extension='1000',
-                    argument='PJSIP/abcdef',
-                )
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        has_properties(
+                            user_id=user_row.id,
+                            extension='1000',
+                            argument='PJSIP/abcdef',
+                        )
+                    ),
+                }
             ),
         )
 
@@ -154,13 +207,17 @@ class TestUserHints(TestHints):
         user_row = self.add_user_sccp_and_func_key(sccpline_row.id, '1001')
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains(
-                has_properties(
-                    user_id=user_row.id,
-                    extension='1001',
-                    argument='SCCP/1001',
-                )
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        has_properties(
+                            user_id=user_row.id,
+                            extension='1001',
+                            argument='SCCP/1001',
+                        )
+                    ),
+                }
             ),
         )
 
@@ -169,30 +226,29 @@ class TestUserHints(TestHints):
         user_row = self.add_user_custom_and_func_key(custom_row.id, '1002')
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains(
-                has_properties(
-                    user_id=user_row.id,
-                    extension='1002',
-                    argument='ghijkl',
-                )
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        has_properties(
+                            user_id=user_row.id,
+                            extension='1002',
+                            argument='ghijkl',
+                        )
+                    ),
+                }
             ),
         )
 
     def test_given_user_with_commented_line_then_returns_empty_list(self):
         self.add_user_and_func_key(exten='1002', commented=1)
 
-        assert_that(hint_dao.user_hints(self.context.name), empty())
+        assert_that(hint_dao.user_hints(), empty())
 
     def test_given_user_with_hints_disabled_then_returns_empty_list(self):
         self.add_user_and_func_key(exten='1003', enablehint=0)
 
-        assert_that(hint_dao.user_hints(self.context.name), empty())
-
-    def test_given_user_when_querying_different_context_then_returns_empty_list(self):
-        self.add_user_and_func_key(exten='1004')
-
-        assert_that(hint_dao.user_hints('othercontext'), empty())
+        assert_that(hint_dao.user_hints(), empty())
 
     def test_given_two_users_with_sip_line_then_returns_only_two_hints(self):
         user1 = self.add_user_and_func_key(
@@ -203,14 +259,18 @@ class TestUserHints(TestHints):
         )
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains_inanyorder(
-                has_properties(
-                    user_id=user1.id, extension='1001', argument='PJSIP/user1'
-                ),
-                has_properties(
-                    user_id=user2.id, extension='1002', argument='PJSIP/user2'
-                ),
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_inanyorder(
+                        has_properties(
+                            user_id=user1.id, extension='1001', argument='PJSIP/user1'
+                        ),
+                        has_properties(
+                            user_id=user2.id, extension='1002', argument='PJSIP/user2'
+                        ),
+                    ),
+                }
             ),
         )
 
@@ -224,13 +284,17 @@ class TestUserHints(TestHints):
         )
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains(
-                has_properties(
-                    user_id=user.id,
-                    extension='1001',
-                    argument='PJSIP/line1&PJSIP/line2',
-                ),
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        has_properties(
+                            user_id=user.id,
+                            extension='1001',
+                            argument='PJSIP/line1&PJSIP/line2',
+                        ),
+                    ),
+                }
             ),
         )
 
@@ -245,18 +309,22 @@ class TestUserHints(TestHints):
         )
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains_inanyorder(
-                has_properties(
-                    user_id=user.id,
-                    extension='1001',
-                    argument='PJSIP/line1&PJSIP/line2',
-                ),
-                has_properties(
-                    user_id=user.id,
-                    extension='1002',
-                    argument='PJSIP/line1&PJSIP/line2',
-                ),
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_inanyorder(
+                        has_properties(
+                            user_id=user.id,
+                            extension='1001',
+                            argument='PJSIP/line1&PJSIP/line2',
+                        ),
+                        has_properties(
+                            user_id=user.id,
+                            extension='1002',
+                            argument='PJSIP/line1&PJSIP/line2',
+                        ),
+                    ),
+                }
             ),
         )
 
@@ -273,13 +341,17 @@ class TestUserHints(TestHints):
         )
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains(
-                has_properties(
-                    user_id=user.id,
-                    extension='1001',
-                    argument='PJSIP/line1&PJSIP/line2',
-                ),
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        has_properties(
+                            user_id=user.id,
+                            extension='1001',
+                            argument='PJSIP/line1&PJSIP/line2',
+                        ),
+                    ),
+                }
             ),
         )
 
@@ -297,72 +369,102 @@ class TestUserHints(TestHints):
         )
 
         assert_that(
-            hint_dao.user_hints(self.context.name),
-            contains_inanyorder(
-                has_properties(
-                    user_id=user.id,
-                    extension='1001',
-                    argument='PJSIP/line1&PJSIP/line2&PJSIP/line3',
-                ),
-                has_properties(
-                    user_id=user.id,
-                    extension='1002',
-                    argument='PJSIP/line1&PJSIP/line2&PJSIP/line3',
-                ),
+            hint_dao.user_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_inanyorder(
+                        has_properties(
+                            user_id=user.id,
+                            extension='1001',
+                            argument='PJSIP/line1&PJSIP/line2&PJSIP/line3',
+                        ),
+                        has_properties(
+                            user_id=user.id,
+                            extension='1002',
+                            argument='PJSIP/line1&PJSIP/line2&PJSIP/line3',
+                        ),
+                    ),
+                }
             ),
         )
 
 
 class TestConferenceHints(TestHints):
     def test_given_conference_then_returns_conference_hint(self):
-        exten = '1234'
-        context = self.add_context(name='default')
-        conference = self.add_conference()
+        exten_1 = '1234'
+        context_1 = self.add_context(name='default')
+        conference_1 = self.add_conference()
         self.add_extension(
-            context=context.name,
-            exten=exten,
+            context=context_1.name,
+            exten=exten_1,
             type='conference',
-            typeval=str(conference.id),
+            typeval=str(conference_1.id),
         )
-        self.add_conference_destination(conference.id)
+        self.add_conference_destination(conference_1.id)
 
-        hints = hint_dao.conference_hints(context.name)
+        exten_2 = '1234'
+        context_2 = self.add_context(name='two')
+        conference_2 = self.add_conference()
+        self.add_extension(
+            context=context_2.name,
+            exten=exten_2,
+            type='conference',
+            typeval=str(conference_2.id),
+        )
+        self.add_conference_destination(conference_2.id)
+
+        hints = hint_dao.conference_hints()
         assert_that(
             hints,
-            contains(
-                Hint(
-                    user_id=None,
-                    conference_id=conference.id,
-                    extension=exten,
-                    argument=None,
-                )
+            has_entries(
+                {
+                    context_1.name: contains_exactly(
+                        Hint(
+                            user_id=None,
+                            conference_id=conference_1.id,
+                            extension=exten_1,
+                            argument=None,
+                        )
+                    ),
+                    context_2.name: contains_exactly(
+                        Hint(
+                            conference_id=conference_2.id,
+                            extension=exten_2,
+                        ),
+                    ),
+                }
             ),
         )
 
-    def test_given_conference_when_querying_different_context_then_returns_no_hints(
-        self,
-    ):
-        conference = self.add_conference()
-        self.add_extension(type='conference', typeval=str(conference.id))
-        self.add_conference_destination(conference.id)
-
-        hints = hint_dao.conference_hints('othercontext')
-        assert_that(hints, empty())
-
 
 class TestServiceHints(TestHints):
     def test_given_service_func_key_then_returns_service_hint(self):
+        context_1 = self.add_context()
+        context_2 = self.add_context()
+        context_3 = self.add_context()
+
         destination_row = self.create_service_func_key('*25', 'enablednd')
 
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
+        user_1 = self.add_sip_user_line_extension_in_context(context_1.name)
+        user_2 = self.add_sip_user_line_extension_in_context(context_2.name)
+        self.add_func_key_to_user(destination_row, user_1)
+        self.add_func_key_to_user(destination_row, user_2)
 
+        result = hint_dao.service_hints()
         assert_that(
-            hint_dao.service_hints(self.context.name),
-            contains(
-                Hint(user_id=user_row.id, extension='*25', argument=None),
+            result,
+            has_entries(
+                {
+                    context_1.name: contains_exactly(
+                        Hint(user_id=user_1.id, extension='*25', argument=None),
+                    ),
+                    context_2.name: contains_exactly(
+                        Hint(user_id=user_2.id, extension='*25', argument=None),
+                    ),
+                }
             ),
         )
+        assert_that(result, not_(has_key(context_3.name)))
 
     def test_given_commented_extension_then_returns_no_hints(self):
         destination_row = self.create_service_func_key('*25', 'enablednd', commented=1)
@@ -370,7 +472,7 @@ class TestServiceHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row)
 
-        assert_that(hint_dao.service_hints(self.context.name), empty())
+        assert_that(hint_dao.service_hints(), empty())
 
     def test_given_no_blf_then_returns_no_hints(self):
         destination_row = self.create_service_func_key('*25', 'enablednd')
@@ -378,7 +480,7 @@ class TestServiceHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row, blf=False)
 
-        assert_that(hint_dao.service_hints(self.context.name), empty())
+        assert_that(hint_dao.service_hints(), empty())
 
     def test_given_user_when_query_different_context_then_returns_no_hints(self):
         destination_row = self.create_service_func_key('*25', 'enablednd')
@@ -386,22 +488,37 @@ class TestServiceHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row, blf=False)
 
-        assert_that(hint_dao.service_hints('othercontext'), empty())
+        assert_that(hint_dao.service_hints(), empty())
 
 
 class TestForwardHints(TestHints):
     def test_given_forward_func_key_then_returns_forward_hint(self):
+        context_1 = self.add_context()
+        context_2 = self.add_context()
+        context_3 = self.add_context()
+
         destination_row = self.create_forward_func_key('_*23.', 'fwdbusy', '1234')
 
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
+        user_1 = self.add_sip_user_line_extension_in_context(context_1.name)
+        user_2 = self.add_sip_user_line_extension_in_context(context_2.name)
+        self.add_func_key_to_user(destination_row, user_1)
+        self.add_func_key_to_user(destination_row, user_2)
 
+        result = hint_dao.forward_hints()
         assert_that(
-            hint_dao.forward_hints(self.context.name),
-            contains(
-                Hint(user_id=user_row.id, extension='*23', argument='1234'),
+            result,
+            has_entries(
+                {
+                    context_1.name: contains_exactly(
+                        Hint(user_id=user_1.id, extension='*23', argument='1234'),
+                    ),
+                    context_2.name: contains_exactly(
+                        Hint(user_id=user_2.id, extension='*23', argument='1234'),
+                    ),
+                }
             ),
         )
+        assert_that(result, not_(has_key(context_3.name)))
 
     def test_given_forward_without_number_then_returns_forward_hint(self):
         destination_row = self.create_forward_func_key('_*23.', 'fwdbusy')
@@ -410,9 +527,13 @@ class TestForwardHints(TestHints):
         self.add_func_key_to_user(destination_row, user_row)
 
         assert_that(
-            hint_dao.forward_hints(self.context.name),
-            contains(
-                Hint(user_id=user_row.id, extension='*23', argument=None),
+            hint_dao.forward_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        Hint(user_id=user_row.id, extension='*23', argument=None),
+                    ),
+                }
             ),
         )
 
@@ -424,7 +545,7 @@ class TestForwardHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row)
 
-        assert_that(hint_dao.forward_hints(self.context.name), contains())
+        assert_that(hint_dao.forward_hints(), empty())
 
     def test_given_no_blf_then_returns_no_hints(self):
         destination_row = self.create_forward_func_key('_*23.', 'fwdbusy', '1234')
@@ -432,15 +553,7 @@ class TestForwardHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row, blf=False)
 
-        assert_that(hint_dao.forward_hints(self.context.name), contains())
-
-    def test_given_user_when_query_other_context_then_returns_no_hints(self):
-        destination_row = self.create_forward_func_key('_*23.', 'fwdbusy', '1234')
-
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
-
-        assert_that(hint_dao.forward_hints('othercontext'), contains())
+        assert_that(hint_dao.forward_hints(), empty())
 
     def test_forward_extension_with_xxx_pattern_is_cleaned(self):
         destination_row = self.create_forward_func_key('_*23XXXX', 'fwdbusy', '1234')
@@ -449,30 +562,53 @@ class TestForwardHints(TestHints):
         self.add_func_key_to_user(destination_row, user_row)
 
         assert_that(
-            hint_dao.forward_hints(self.context.name),
-            contains(
-                Hint(user_id=user_row.id, extension='*23', argument='1234'),
+            hint_dao.forward_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        Hint(user_id=user_row.id, extension='*23', argument='1234'),
+                    ),
+                }
             ),
         )
 
 
 class TestAgentHints(TestHints):
     def test_given_agent_func_key_then_returns_agent_hint(self):
+        context_1 = self.add_context()
+        context_2 = self.add_context()
+        context_3 = self.add_context()
+
         destination_row = self.create_agent_func_key('_*31.', 'agentstaticlogin')
 
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
+        user_1 = self.add_sip_user_line_extension_in_context(context_1.name)
+        user_2 = self.add_sip_user_line_extension_in_context(context_2.name)
+        self.add_func_key_to_user(destination_row, user_1)
+        self.add_func_key_to_user(destination_row, user_2)
 
+        result = hint_dao.agent_hints()
         assert_that(
-            hint_dao.agent_hints(self.context.name),
-            contains(
-                Hint(
-                    user_id=user_row.id,
-                    extension='*31',
-                    argument=str(destination_row.agent_id),
-                ),
+            result,
+            has_entries(
+                {
+                    context_1.name: contains_exactly(
+                        Hint(
+                            user_id=user_1.id,
+                            extension='*31',
+                            argument=str(destination_row.agent_id),
+                        ),
+                    ),
+                    context_2.name: contains_exactly(
+                        Hint(
+                            user_id=user_2.id,
+                            extension='*31',
+                            argument=str(destination_row.agent_id),
+                        ),
+                    ),
+                }
             ),
         )
+        assert_that(result, not_(has_key(context_3.name)))
 
     def test_given_commented_extension_then_returns_no_hints(self):
         destination_row = self.create_agent_func_key('_*31.', 'agentstaticlogin')
@@ -480,7 +616,7 @@ class TestAgentHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row, blf=False)
 
-        assert_that(hint_dao.agent_hints(self.context.name), empty())
+        assert_that(hint_dao.agent_hints(), empty())
 
     def test_given_no_blf_then_returns_no_hints(self):
         destination_row = self.create_agent_func_key('_*31.', 'agentstaticlogin')
@@ -488,15 +624,7 @@ class TestAgentHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row, blf=False)
 
-        assert_that(hint_dao.agent_hints(self.context.name), empty())
-
-    def test_given_user_when_querying_other_context_then_returns_no_hints(self):
-        destination_row = self.create_agent_func_key('_*31.', 'agentstaticlogin')
-
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
-
-        assert_that(hint_dao.agent_hints('othercontext'), empty())
+        assert_that(hint_dao.agent_hints(), empty())
 
     def test_agent_extension_with_xxx_pattern_is_cleaned(self):
         destination_row = self.create_agent_func_key('_*31XXXX', 'agentstaticlogin')
@@ -505,38 +633,49 @@ class TestAgentHints(TestHints):
         self.add_func_key_to_user(destination_row, user_row)
 
         assert_that(
-            hint_dao.agent_hints(self.context.name),
-            contains(
-                Hint(
-                    user_id=user_row.id,
-                    extension='*31',
-                    argument=str(destination_row.agent_id),
-                ),
+            hint_dao.agent_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        Hint(
+                            user_id=user_row.id,
+                            extension='*31',
+                            argument=str(destination_row.agent_id),
+                        ),
+                    ),
+                }
             ),
         )
 
 
 class TestCustomHints(TestHints):
     def test_given_custom_func_key_then_returns_custom_hint(self):
+        context_1 = self.add_context()
+        context_2 = self.add_context()
+        context_3 = self.add_context()
+
         destination_row = self.create_custom_func_key('1234')
 
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
+        user_1 = self.add_sip_user_line_extension_in_context(context_1.name)
+        user_2 = self.add_sip_user_line_extension_in_context(context_2.name)
+        self.add_func_key_to_user(destination_row, user_1)
+        self.add_func_key_to_user(destination_row, user_2)
 
+        result = hint_dao.custom_hints()
         assert_that(
-            hint_dao.custom_hints(self.context.name),
-            contains(
-                Hint(user_id=None, extension='1234', argument=None),
+            result,
+            has_entries(
+                {
+                    context_1.name: contains_exactly(
+                        Hint(user_id=None, extension='1234', argument=None),
+                    ),
+                    context_2.name: contains_exactly(
+                        Hint(user_id=None, extension='1234', argument=None),
+                    ),
+                }
             ),
         )
-
-    def test_given_user_when_querying_other_context_then_returns_no_hints(self):
-        destination_row = self.create_custom_func_key('1234')
-
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
-
-        assert_that(hint_dao.custom_hints('othercontext'), empty())
+        assert_that(result, not_(has_key(context_3.name)))
 
 
 class TestBSFilterHints(TestHints):
@@ -565,37 +704,62 @@ class TestBSFilterHints(TestHints):
         _, filtermember_row = self.create_boss_and_secretary()
 
         assert_that(
-            hint_dao.bsfilter_hints(self.context.name),
-            contains(
-                Hint(user_id=None, extension='*37', argument=str(filtermember_row.id)),
+            hint_dao.bsfilter_hints(),
+            has_entries(
+                {
+                    self.context.name: contains_exactly(
+                        Hint(
+                            user_id=None,
+                            extension='*37',
+                            argument=str(filtermember_row.id),
+                        ),
+                    ),
+                }
             ),
         )
 
     def test_given_commented_bs_filter_func_key_then_returns_empty_list(self):
         self.create_boss_and_secretary(commented=1)
 
-        assert_that(hint_dao.bsfilter_hints(self.context.name), empty())
-
-    def test_given_secretary_when_querying_different_context_then_returns_no_hints(
-        self,
-    ):
-        self.create_boss_and_secretary()
-
-        assert_that(hint_dao.bsfilter_hints('othercontext'), empty())
+        assert_that(hint_dao.bsfilter_hints(), empty())
 
 
 class TestGroupHints(TestHints):
     def test_given_group_member_func_key_then_returns_group_member_hint(self):
+        context_1 = self.add_context()
+        context_2 = self.add_context()
+        context_3 = self.add_context()
+
         destination_row = self.create_group_member_func_key('_*51.', 'groupmemberjoin')
 
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
+        user_1 = self.add_sip_user_line_extension_in_context(context_1.name)
+        user_2 = self.add_sip_user_line_extension_in_context(context_2.name)
+        self.add_func_key_to_user(destination_row, user_1)
+        self.add_func_key_to_user(destination_row, user_2)
 
-        expected = Hint(
-            user_id=user_row.id, extension='*51', argument=str(destination_row.group_id)
+        result = hint_dao.groupmember_hints()
+        assert_that(
+            result,
+            has_entries(
+                {
+                    context_1.name: contains_exactly(
+                        Hint(
+                            user_id=user_1.id,
+                            extension='*51',
+                            argument=str(destination_row.group_id),
+                        ),
+                    ),
+                    context_2.name: contains_exactly(
+                        Hint(
+                            user_id=user_2.id,
+                            extension='*51',
+                            argument=str(destination_row.group_id),
+                        ),
+                    ),
+                }
+            ),
         )
-
-        assert_that(hint_dao.groupmember_hints(self.context.name), contains(expected))
+        assert_that(result, not_(has_key(context_3.name)))
 
     def test_given_commented_extension_then_returns_no_hints(self):
         destination_row = self.create_group_member_func_key('_*51.', 'groupmemberjoin')
@@ -603,7 +767,7 @@ class TestGroupHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row, blf=False)
 
-        assert_that(hint_dao.groupmember_hints(self.context.name), contains())
+        assert_that(hint_dao.groupmember_hints(), empty())
 
     def test_given_no_blf_then_returns_no_hints(self):
         destination_row = self.create_group_member_func_key('_*51.', 'groupmemberjoin')
@@ -611,15 +775,7 @@ class TestGroupHints(TestHints):
         user_row = self.add_user_and_func_key()
         self.add_func_key_to_user(destination_row, user_row, blf=False)
 
-        assert_that(hint_dao.groupmember_hints(self.context.name), contains())
-
-    def test_given_user_when_querying_other_context_then_returns_no_hints(self):
-        destination_row = self.create_group_member_func_key('_*51.', 'groupmemberjoin')
-
-        user_row = self.add_user_and_func_key()
-        self.add_func_key_to_user(destination_row, user_row)
-
-        assert_that(hint_dao.groupmember_hints('othercontext'), contains())
+        assert_that(hint_dao.groupmember_hints(), empty())
 
     def test_group_extension_with_xxx_pattern_is_cleaned(self):
         destination_row = self.create_group_member_func_key(
@@ -633,7 +789,10 @@ class TestGroupHints(TestHints):
             user_id=user_row.id, extension='*51', argument=str(destination_row.group_id)
         )
 
-        assert_that(hint_dao.groupmember_hints(self.context.name), contains(expected))
+        assert_that(
+            hint_dao.groupmember_hints(),
+            has_entries({self.context.name: contains_exactly(expected)}),
+        )
 
 
 class TestUserSharedHints(TestHints):
diff --git a/wazo_confgend/hints/adaptor.py b/wazo_confgend/hints/adaptor.py
index f31ed26..8efeed9 100644
--- a/wazo_confgend/hints/adaptor.py
+++ b/wazo_confgend/hints/adaptor.py
@@ -1,4 +1,4 @@
-# Copyright 2014-2023 The Wazo Authors  (see the AUTHORS file)
+# Copyright 2014-2024 The Wazo Authors  (see the AUTHORS file)
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 import logging
@@ -28,8 +28,13 @@ class ProgfunckeyAdaptor(HintAdaptor):
 
 
 class UserAdaptor(HintAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.user_hints()
+
     def generate(self, context):
-        for hint in self.dao.user_hints(context):
+        hints = self._hints.get(context) or []
+        for hint in hints:
             yield (hint.extension, hint.argument)
 
 
@@ -40,46 +45,72 @@ class UserSharedHintAdaptor(HintAdaptor):
 
 
 class ConferenceAdaptor(HintAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.conference_hints()
+
     def generate(self, context):
-        for hint in self.dao.conference_hints(context):
+        hints = self._hints.get(context) or []
+        for hint in hints:
             yield (hint.extension, f'confbridge:{hint.conference_id}')
 
 
 class ForwardAdaptor(ProgfunckeyAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.forward_hints()
+
     def find_hints(self, context):
-        return self.dao.forward_hints(context)
+        return self._hints.get(context) or []
 
     def progfunckey_arguments(self, hint):
         return [hint.user_id, hint.extension, hint.argument]
 
 
 class GroupMemberAdaptor(ProgfunckeyAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.groupmember_hints()
+
     def find_hints(self, context):
-        return self.dao.groupmember_hints(context)
+        return self._hints.get(context) or []
 
     def progfunckey_arguments(self, hint):
         return [hint.user_id, hint.extension, hint.argument]
 
 
 class ServiceAdaptor(ProgfunckeyAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.service_hints()
+
     def find_hints(self, context):
-        return self.dao.service_hints(context)
+        return self._hints.get(context) or []
 
     def progfunckey_arguments(self, hint):
         return [hint.user_id, hint.extension, hint.argument]
 
 
 class AgentAdaptor(ProgfunckeyAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.agent_hints()
+
     def find_hints(self, context):
-        return self.dao.agent_hints(context)
+        return self._hints.get(context) or []
 
     def progfunckey_arguments(self, hint):
         return [hint.user_id, hint.extension, '*' + hint.argument]
 
 
 class CustomAdaptor(HintAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.custom_hints()
+
     def generate(self, context):
-        for hint in self.dao.custom_hints(context):
+        hints = self._hints.get(context) or []
+        for hint in hints:
             try:
                 yield (hint.extension, f'Custom:{hint.extension}')
             except UnicodeEncodeError:
@@ -88,7 +119,12 @@ class CustomAdaptor(HintAdaptor):
 
 
 class BSFilterAdaptor(HintAdaptor):
+    def __init__(self, dao):
+        super().__init__(dao)
+        self._hints = self.dao.bsfilter_hints()
+
     def generate(self, context):
-        for hint in self.dao.bsfilter_hints(context):
+        hints = self._hints.get(context) or []
+        for hint in hints:
             extension = f'{hint.extension}{hint.argument}'
             yield (extension, f'Custom:{extension}')
diff --git a/wazo_confgend/hints/tests/test_adaptor.py b/wazo_confgend/hints/tests/test_adaptor.py
index 7cfb4bd..ee2af90 100644
--- a/wazo_confgend/hints/tests/test_adaptor.py
+++ b/wazo_confgend/hints/tests/test_adaptor.py
@@ -1,4 +1,4 @@
-# Copyright 2014-2023 The Wazo Authors  (see the AUTHORS file)
+# Copyright 2014-2024 The Wazo Authors  (see the AUTHORS file)
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 
@@ -31,15 +31,15 @@ class TestUserAdaptor(TestAdaptor):
     def setUp(self):
         super().setUp()
         self.dao = Mock()
-        self.dao.user_hints.return_value = [
-            Hint(user_id=42, extension='1000', argument='SIP/abcdef')
-        ]
+        self.dao.user_hints.return_value = {
+            CONTEXT: [Hint(user_id=42, extension='1000', argument='SIP/abcdef')],
+        }
 
         self.adaptor = UserAdaptor(self.dao)
 
     def test_adaptor_generates_user_hint(self):
         assert_that(self.adaptor.generate(CONTEXT), has_item(('1000', 'SIP/abcdef')))
-        self.dao.user_hints.assert_called_once_with(CONTEXT)
+        self.dao.user_hints.assert_called_once_with()
 
 
 class TestUserSharedHintsAdaptor(TestAdaptor):
@@ -76,14 +76,16 @@ class TestUserSharedHintsAdaptor(TestAdaptor):
 class TestConferenceAdaptor(TestAdaptor):
     def test_adaptor_generates_conference_hint(self):
         dao = Mock()
-        dao.conference_hints.return_value = [Hint(conference_id=1, extension='4000')]
+        dao.conference_hints.return_value = {
+            CONTEXT: [Hint(conference_id=1, extension='4000')]
+        }
 
         adaptor = ConferenceAdaptor(dao)
 
         assert_that(
             adaptor.generate(CONTEXT), contains_exactly(('4000', 'confbridge:1'))
         )
-        dao.conference_hints.assert_called_once_with(CONTEXT)
+        dao.conference_hints.assert_called_once_with()
 
 
 class TestForwardAdaptor(TestAdaptor):
@@ -92,29 +94,35 @@ class TestForwardAdaptor(TestAdaptor):
         self.dao = Mock()
         self.dao.progfunckey_extension.return_value = '*735'
 
-        self.adaptor = ForwardAdaptor(self.dao)
-
     def test_given_hint_with_argument_then_generates_progfunckey_with_argument(self):
-        self.dao.forward_hints.return_value = [
-            Hint(user_id=42, extension='*23', argument='1234')
-        ]
+        self.dao.forward_hints.return_value = {
+            CONTEXT: [
+                Hint(user_id=42, extension='*23', argument='1234'),
+            ],
+        }
+        self.adaptor = ForwardAdaptor(self.dao)
 
         assert_that(
             self.adaptor.generate(CONTEXT),
-            contains_exactly(('*73542***223*1234', 'Custom:*73542***223*1234')),
+            contains_exactly(
+                ('*73542***223*1234', 'Custom:*73542***223*1234'),
+            ),
         )
-        self.dao.forward_hints.assert_called_once_with(CONTEXT)
+        self.dao.forward_hints.assert_called_once_with()
 
     def test_given_hint_without_argument_then_generates_progfunckey_without_argument(
         self,
     ):
-        self.dao.forward_hints.return_value = [
-            Hint(user_id=42, extension='*23', argument=None)
-        ]
+        self.dao.forward_hints.return_value = {
+            CONTEXT: [Hint(user_id=42, extension='*23', argument=None)],
+        }
+        self.adaptor = ForwardAdaptor(self.dao)
 
         assert_that(
             self.adaptor.generate(CONTEXT),
-            contains_exactly(('*73542***223', 'Custom:*73542***223')),
+            contains_exactly(
+                ('*73542***223', 'Custom:*73542***223'),
+            ),
         )
 
 
@@ -122,9 +130,9 @@ class TestServiceAdaptor(TestAdaptor):
     def test_adaptor_generates_service_hint(self):
         dao = Mock()
         dao.progfunckey_extension.return_value = '*735'
-        dao.service_hints.return_value = [
-            Hint(user_id=42, extension='*26', argument=None)
-        ]
+        dao.service_hints.return_value = {
+            CONTEXT: [Hint(user_id=42, extension='*26', argument=None)],
+        }
 
         adaptor = ServiceAdaptor(dao)
 
@@ -132,16 +140,16 @@ class TestServiceAdaptor(TestAdaptor):
             adaptor.generate(CONTEXT),
             contains_exactly(('*73542***226', 'Custom:*73542***226')),
         )
-        dao.service_hints.assert_called_once_with(CONTEXT)
+        dao.service_hints.assert_called_once_with()
 
 
 class TestAgentAdaptor(TestAdaptor):
     def test_adaptor_generates_service_hint(self):
         dao = Mock()
         dao.progfunckey_extension.return_value = '*735'
-        dao.agent_hints.return_value = [
-            Hint(user_id=42, extension='*31', argument='56')
-        ]
+        dao.agent_hints.return_value = {
+            CONTEXT: [Hint(user_id=42, extension='*31', argument='56')],
+        }
 
         adaptor = AgentAdaptor(dao)
 
@@ -149,28 +157,30 @@ class TestAgentAdaptor(TestAdaptor):
             adaptor.generate(CONTEXT),
             contains_exactly(('*73542***231***356', 'Custom:*73542***231***356')),
         )
-        dao.agent_hints.assert_called_once_with(CONTEXT)
+        dao.agent_hints.assert_called_once_with()
 
 
 class TestCustomAdaptor(TestAdaptor):
     def test_adaptor_generates_custom_hint(self):
         dao = Mock()
-        dao.custom_hints.return_value = [
-            Hint(user_id=None, extension='1234', argument=None)
-        ]
+        dao.custom_hints.return_value = {
+            CONTEXT: [Hint(user_id=None, extension='1234', argument=None)],
+        }
 
         adaptor = CustomAdaptor(dao)
 
         assert_that(
             adaptor.generate(CONTEXT), contains_exactly(('1234', 'Custom:1234'))
         )
-        dao.custom_hints.assert_called_once_with(CONTEXT)
+        dao.custom_hints.assert_called_once_with()
 
     def test_that_non_ascii_characters_are_ignored(self):
         dao = Mock()
-        dao.custom_hints.return_value = [
-            Hint(user_id=None, extension='\xe9', argument=None),
-        ]
+        dao.custom_hints.return_value = {
+            CONTEXT: [
+                Hint(user_id=None, extension='\xe9', argument=None),
+            ],
+        }
 
         adaptor = CustomAdaptor(dao)
 
@@ -179,31 +189,31 @@ class TestCustomAdaptor(TestAdaptor):
         except Exception:
             raise AssertionError('Should not raise')
 
-        dao.custom_hints.assert_called_once_with(CONTEXT)
+        dao.custom_hints.assert_called_once_with()
 
 
 class TestBSFilterAdaptor(TestAdaptor):
     def test_adaptor_generates_bsfilter_hint(self):
         dao = Mock()
-        dao.bsfilter_hints.return_value = [
-            Hint(user_id=42, extension='*37', argument='12')
-        ]
+        dao.bsfilter_hints.return_value = {
+            CONTEXT: [Hint(user_id=42, extension='*37', argument='12')],
+        }
 
         adaptor = BSFilterAdaptor(dao)
 
         assert_that(
             adaptor.generate(CONTEXT), contains_exactly(('*3712', 'Custom:*3712'))
         )
-        dao.bsfilter_hints.assert_called_once_with(CONTEXT)
+        dao.bsfilter_hints.assert_called_once_with()
 
 
 class TestGroupMemberAdaptor(TestAdaptor):
     def test_adaptor_generates_groupmember_hint(self):
         dao = Mock()
         dao.progfunckey_extension.return_value = '*735'
-        dao.groupmember_hints.return_value = [
-            Hint(user_id=42, extension='*50', argument='18')
-        ]
+        dao.groupmember_hints.return_value = {
+            CONTEXT: [Hint(user_id=42, extension='*50', argument='18')],
+        }
 
         adaptor = GroupMemberAdaptor(dao)
 
@@ -211,4 +221,4 @@ class TestGroupMemberAdaptor(TestAdaptor):
             adaptor.generate(CONTEXT),
             contains_exactly(('*73542***250*18', 'Custom:*73542***250*18')),
         )
-        dao.groupmember_hints.assert_called_once_with(CONTEXT)
+        dao.groupmember_hints.assert_called_once_with()