[REM] core,*: remove name_get_uid parameter from _name_search.

`name_get_uid` is unused (at least since v14) and the
documentation about it, is wrong.

closes odoo/odoo#117819

Related: odoo/enterprise#39483
Signed-off-by: Rémy Voet <ryv@odoo.com>

addons/account/models/account_account.py

@@ -559,7 +559,7 @@ class AccountAccount(models.Model):
         return self._get_most_frequent_accounts_for_partner(company_id, partner_id, move_type)
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         if not name and self._context.get('partner_id') and self._context.get('move_type'):
             return self._order_accounts_by_frequency_for_partner(
                             self.env.company.id, self._context.get('partner_id'), self._context.get('move_type'))
@@ -572,7 +572,7 @@ class AccountAccount(models.Model):
             if operator in expression.NEGATIVE_TERM_OPERATORS:
                 name_domain = ['&', '!'] + name_domain[1:]
             domain = expression.AND([name_domain, domain])
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)
 
     @api.onchange('account_type')
     def _onchange_account_type(self):
@@ -833,13 +833,13 @@ class AccountGroup(models.Model):
         return result
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         if operator != 'ilike' or (name or '').strip():
             criteria_operator = ['|'] if operator not in expression.NEGATIVE_TERM_OPERATORS else ['&', '!']
             name_domain = criteria_operator + [('code_prefix_start', '=ilike', name + '%'), ('name', operator, name)]
             domain = expression.AND([name_domain, domain])
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)
 
     @api.constrains('code_prefix_start', 'code_prefix_end')
     def _constraint_prefix_overlap(self):

addons/account/models/account_tax.py

@@ -252,10 +252,10 @@ class AccountTax(models.Model):
         return ''.join(list_name)
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         if operator in ("ilike", "like"):
             name = AccountTax._parse_name_search(name)
-        return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+        return super()._name_search(name, domain, operator, limit, order)
 
     def _search_name(self, operator, value):
         if operator not in ("ilike", "like") or not isinstance(value, str):

addons/event/models/mail_template.py

@@ -9,7 +9,7 @@ class MailTemplate(models.Model):
     _inherit = 'mail.template'
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         """Context-based hack to filter reference field in a m2o search box to emulate a domain the ORM currently does not support.
 
         As we can not specify a domain on a reference field, we added a context
@@ -19,4 +19,4 @@ class MailTemplate(models.Model):
         """
         if self.env.context.get('filter_template_on_event'):
             domain = expression.AND([[('model', '=', 'event.registration')], domain])
-        return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+        return super()._name_search(name, domain, operator, limit, order)

addons/event_sms/models/sms_template.py

@@ -9,7 +9,7 @@ class SmsTemplate(models.Model):
     _inherit = 'sms.template'
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         """Context-based hack to filter reference field in a m2o search box to emulate a domain the ORM currently does not support.
 
         As we can not specify a domain on a reference field, we added a context
@@ -19,4 +19,4 @@ class SmsTemplate(models.Model):
         """
         if self.env.context.get('filter_template_on_event'):
             domain = expression.AND([[('model', '=', 'event.registration')], domain])
-        return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+        return super()._name_search(name, domain, operator, limit, order)

addons/fleet/models/fleet_vehicle_model.py

@@ -46,12 +46,12 @@ class FleetVehicleModel(models.Model):
     electric_assistance = fields.Boolean(default=False)
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         if operator != 'ilike' or (name or '').strip():
             name_domain = ['|', ('name', 'ilike', name), ('brand_id.name', 'ilike', name)]
             domain = expression.AND([name_domain, domain])
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)
 
     def name_get(self):
         res = []

addons/im_livechat/models/chatbot_script_answer.py

@@ -38,7 +38,7 @@ class ChatbotScriptAnswer(models.Model):
         return result
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         """
         Search the records whose name or step message are matching the ``name`` pattern.
         The chatbot_script_id is also passed to the context through the custom widget
@@ -57,4 +57,4 @@ class ChatbotScriptAnswer(models.Model):
         if force_domain_chatbot_script_id:
             domain = expression.AND([domain, [('chatbot_script_id', '=', force_domain_chatbot_script_id)]])
 
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)

addons/l10n_eg_edi_eta/models/eta_activity_type.py

@@ -14,9 +14,9 @@ class EtaActivityType(models.Model):
     code = fields.Char(required=True)
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         if operator != 'ilike' or not (name or '').strip():
             # ignore 'ilike' with name containing only spaces
             domain = expression.AND([['|', ('name', operator, name), ('code', operator, name)], domain])
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)

addons/maintenance/models/maintenance.py

@@ -102,12 +102,12 @@ class MaintenanceEquipment(models.Model):
         return result
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         query = None
         if name and operator not in expression.NEGATIVE_TERM_OPERATORS and operator != '=':
-            query = self._search([('name', '=', name)] + domain, limit=limit, order=order, access_rights_uid=name_get_uid)
-        return query or super()._name_search(name, domain, operator, limit, order, name_get_uid)
+            query = self._search([('name', '=', name)] + domain, limit=limit, order=order)
+        return query or super()._name_search(name, domain, operator, limit, order)
 
     name = fields.Char('Equipment Name', required=True, translate=True)
     company_id = fields.Many2one('res.company', string='Company',

addons/product/models/product_product.py

@@ -498,15 +498,15 @@ class ProductProduct(models.Model):
         return result
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         if name:
             positive_operators = ['=', 'ilike', '=ilike', 'like', '=like']
             product_ids = []
             if operator in positive_operators:
-                product_ids = list(self._search([('default_code', '=', name)] + domain, limit=limit, order=order, access_rights_uid=name_get_uid))
+                product_ids = list(self._search([('default_code', '=', name)] + domain, limit=limit, order=order))
                 if not product_ids:
-                    product_ids = list(self._search([('barcode', '=', name)] + domain, limit=limit, order=order, access_rights_uid=name_get_uid))
+                    product_ids = list(self._search([('barcode', '=', name)] + domain, limit=limit, order=order))
             if not product_ids and operator not in expression.NEGATIVE_TERM_OPERATORS:
                 # Do not merge the 2 next lines into one single search, SQL search performance would be abysmal
                 # on a database with thousands of matching products, due to the huge merge+unique needed for the
@@ -516,7 +516,7 @@ class ProductProduct(models.Model):
                 if not limit or len(product_ids) < limit:
                     # we may underrun the limit because of dupes in the results, that's fine
                     limit2 = (limit - len(product_ids)) if limit else False
-                    product2_ids = self._search(domain + [('name', operator, name), ('id', 'not in', product_ids)], limit=limit2, order=order, access_rights_uid=name_get_uid)
+                    product2_ids = self._search(domain + [('name', operator, name), ('id', 'not in', product_ids)], limit=limit2, order=order)
                     product_ids.extend(product2_ids)
             elif not product_ids and operator in expression.NEGATIVE_TERM_OPERATORS:
                 domain2 = expression.OR([
@@ -524,23 +524,23 @@ class ProductProduct(models.Model):
                     ['&', ('default_code', '=', False), ('name', operator, name)],
                 ])
                 domain2 = expression.AND([domain, domain2])
-                product_ids = list(self._search(domain2, limit=limit, order=order, access_rights_uid=name_get_uid))
+                product_ids = list(self._search(domain2, limit=limit, order=order))
             if not product_ids and operator in positive_operators:
                 ptrn = re.compile('(\[(.*?)\])')
                 res = ptrn.search(name)
                 if res:
-                    product_ids = list(self._search([('default_code', '=', res.group(2))] + domain, limit=limit, order=order, access_rights_uid=name_get_uid))
+                    product_ids = list(self._search([('default_code', '=', res.group(2))] + domain, limit=limit, order=order))
             # still no results, partner in context: search on supplier info as last hope to find something
             if not product_ids and self._context.get('partner_id'):
                 suppliers_ids = self.env['product.supplierinfo']._search([
                     ('partner_id', '=', self._context.get('partner_id')),
                     '|',
                     ('product_code', operator, name),
-                    ('product_name', operator, name)], access_rights_uid=name_get_uid)
+                    ('product_name', operator, name)])
                 if suppliers_ids:
-                    product_ids = self._search([('product_tmpl_id.seller_ids', 'in', suppliers_ids)], limit=limit, order=order, access_rights_uid=name_get_uid)
+                    product_ids = self._search([('product_tmpl_id.seller_ids', 'in', suppliers_ids)], limit=limit, order=order)
         else:
-            product_ids = self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+            product_ids = self._search(domain, limit=limit, order=order)
         return product_ids
 
     @api.model

addons/product/models/product_template.py

@@ -490,12 +490,12 @@ class ProductTemplate(models.Model):
                 for template in self]
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         # Only use the product.product heuristics if there is a search term and the domain
         # does not specify a match on `product.template` IDs.
         domain = domain or []
         if not name or any(term[0] == 'id' for term in domain):
-            return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+            return super()._name_search(name, domain, operator, limit, order)
 
         Product = self.env['product.product']
         templates = self.browse()
@@ -503,7 +503,7 @@ class ProductTemplate(models.Model):
             extra = templates and [('product_tmpl_id', 'not in', templates.ids)] or []
             # Product._name_search has default value limit=100
             # So, we either use that value or override it to None to fetch all products at once
-            products_ids = Product._name_search(name, domain + extra, operator, limit=None, name_get_uid=name_get_uid)
+            products_ids = Product._name_search(name, domain + extra, operator, limit=None)
             products = Product.browse(products_ids)
             new_templates = products.product_tmpl_id
             if new_templates & templates:
@@ -525,11 +525,11 @@ class ProductTemplate(models.Model):
             tmpl_without_variant = self.search([('id', 'not in', tmpl_with_variant_ids)])
         if tmpl_without_variant:
             domain2 = expression.AND([domain, [('id', 'in', tmpl_without_variant.ids)]])
-            searched_ids |= set(super()._name_search(name, domain2, operator, limit, order, name_get_uid))
+            searched_ids |= set(super()._name_search(name, domain2, operator, limit, order))
 
         # re-apply product.template order + name_get
         domain = [('id', 'in', list(searched_ids))]
-        return super()._name_search('', domain, 'ilike', limit, order, name_get_uid)
+        return super()._name_search('', domain, 'ilike', limit, order)
 
     def action_open_label_layout(self):
         action = self.env['ir.actions.act_window']._for_xml_id('product.action_open_label_layout')

addons/project/models/project_tags.py

@@ -44,7 +44,7 @@ class ProjectTags(models.Model):
         return super().search_read(domain=domain, fields=fields, offset=offset, limit=limit, order=order)
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         if self.env.context.get('project_id') and operator == 'ilike':
             # `domain` has the form of the default filter ['!', ['id', 'in', <ids>]]
             # passed to exclude already selected tags -> exclude them in our query too
@@ -99,7 +99,7 @@ class ProjectTags(models.Model):
             self.env.cr.execute(query, params)
             return [row[0] for row in self.env.cr.fetchall()]
         else:
-            return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+            return super()._name_search(name, domain, operator, limit, order)
 
     @api.model
     def name_create(self, name):

addons/sale_expense/models/sale_order.py

@@ -12,7 +12,7 @@ class SaleOrder(models.Model):
     expense_count = fields.Integer("# of Expenses", compute='_compute_expense_count', compute_sudo=True)
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         """ For expense, we want to show all sales order but only their name_get (no ir.rule applied), this is the only way to do it. """
         if (
             self._context.get('sale_expense_all_order')
@@ -20,8 +20,8 @@ class SaleOrder(models.Model):
             and not self.user_has_groups('sales_team.group_sale_salesman_all_leads')
         ):
             domain = expression.AND([domain or [], ['&', ('state', '=', 'sale'), ('company_id', 'in', self.env.companies.ids)]])
-            return super(SaleOrder, self.sudo())._name_search(name, domain, operator, limit, order, name_get_uid)
-        return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+            return super(SaleOrder, self.sudo())._name_search(name, domain, operator, limit, order)
+        return super()._name_search(name, domain, operator, limit, order)
 
     @api.depends('expense_ids')
     def _compute_expense_count(self):

addons/stock/models/stock_picking.py

@@ -172,13 +172,13 @@ class PickingType(models.Model):
         return res
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         # Try to reverse the `name_get` structure
         parts = name.split(': ')
         if len(parts) == 2:
             name_domain = [('warehouse_id.name', operator, parts[0]), ('name', operator, parts[1])]
-            return self._search(expression.AND([name_domain, domain]), limit=limit, order=order, access_rights_uid=name_get_uid)
-        return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+            return self._search(expression.AND([name_domain, domain]), limit=limit, order=order)
+        return super()._name_search(name, domain, operator, limit, order)
 
     @api.onchange('code')
     def _onchange_picking_code(self):

addons/website/models/website_rewrite.py

@@ -20,11 +20,11 @@ class WebsiteRoute(models.Model):
     path = fields.Char('Route')
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
-        query = super()._name_search(name, domain, operator, limit, order, name_get_uid)
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
+        query = super()._name_search(name, domain, operator, limit, order)
         if not query:
             self._refresh()
-            return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+            return super()._name_search(name, domain, operator, limit, order)
         return query
 
     def _refresh(self):

odoo/addons/base/models/res_bank.py

@@ -38,14 +38,14 @@ class Bank(models.Model):
         return result
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         if name:
             name_domain = ['|', ('bic', '=ilike', name + '%'), ('name', operator, name)]
             if operator in expression.NEGATIVE_TERM_OPERATORS:
                 name_domain = ['&', '!'] + name_domain[1:]
             domain = domain + name_domain
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)
 
     @api.onchange('country')
     def _onchange_country_id(self):

odoo/addons/base/models/res_company.py

@@ -151,7 +151,7 @@ class Company(models.Model):
             self.currency_id = self.country_id.currency_id
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         context = dict(self.env.context)
         newself = self
         if context.pop('user_preference', None):
@@ -163,7 +163,7 @@ class Company(models.Model):
             domain = (domain or []) + [('id', 'in', companies.ids)]
             newself = newself.sudo()
         self = newself.with_context(context)
-        return super()._name_search(name, domain, operator, limit, order, name_get_uid)
+        return super()._name_search(name, domain, operator, limit, order)
 
     @api.model
     @api.returns('self', lambda value: value.id)

odoo/addons/base/models/res_country.py

@@ -82,7 +82,7 @@ class Country(models.Model):
             'The code of the country must be unique!')
     ]
 
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         if domain is None:
             domain = []
 
@@ -169,7 +169,7 @@ class CountryState(models.Model):
     ]
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         if self.env.context.get('country_id'):
             domain = expression.AND([domain, [('country_id', '=', self.env.context.get('country_id'))]])
@@ -184,12 +184,12 @@ class CountryState(models.Model):
         first_state_ids = []
         if domain1:
             first_state_ids = list(self._search(
-                expression.AND([domain1, domain]), limit=limit, order=order, access_rights_uid=name_get_uid,
+                expression.AND([domain1, domain]), limit=limit, order=order,
             ))
         return first_state_ids + [
             state_id
             for state_id in self._search(expression.AND([domain2, domain]),
-                                         limit=limit, order=order, access_rights_uid=name_get_uid)
+                                         limit=limit, order=order)
             if state_id not in first_state_ids
         ]
 

odoo/addons/base/models/res_currency.py

@@ -448,8 +448,8 @@ class CurrencyRate(models.Model):
                 }
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
-        return super()._name_search(parse_date(self.env, name), domain, operator, limit, order, name_get_uid)
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
+        return super()._name_search(parse_date(self.env, name), domain, operator, limit, order)
 
     @api.model
     def _get_view_cache_key(self, view_id=None, view_type='form', **options):

odoo/addons/base/models/res_partner.py

@@ -143,13 +143,13 @@ class PartnerCategory(models.Model):
         return res
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         if name:
             # Be sure name_search is symetric to name_get
             name = name.split(' / ')[-1]
             domain = [('name', operator, name)] + domain
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)
 
 
 class PartnerTitle(models.Model):

odoo/addons/base/models/res_users.py

@@ -648,7 +648,7 @@ class Users(models.Model):
         self.clear_caches()
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         domain = domain or []
         user_ids = []
         if operator not in expression.NEGATIVE_TERM_OPERATORS:
@@ -656,9 +656,9 @@ class Users(models.Model):
                 name_domain = []
             else:
                 name_domain = [('login', '=', name)]
-            user_ids = self._search(expression.AND([name_domain, domain]), limit=limit, order=order, access_rights_uid=name_get_uid)
+            user_ids = self._search(expression.AND([name_domain, domain]), limit=limit, order=order)
         if not user_ids:
-            user_ids = self._search(expression.AND([[('name', operator, name)], domain]), limit=limit, order=order, access_rights_uid=name_get_uid)
+            user_ids = self._search(expression.AND([[('name', operator, name)], domain]), limit=limit, order=order)
         return user_ids
 
     def copy(self, default=None):

odoo/addons/test_impex/models.py

@@ -50,9 +50,9 @@ for name, field in MODELS:
             return [(record.id, "%s:%s" % (self._name, record.value)) for record in self]
 
         @api.model
-        def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+        def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
             if isinstance(name, str) and name.split(':')[0] == self._name:
-                return self._search([('value', operator, int(name.split(':')[1]))], limit=limit, order=order, access_rights_uid=name_get_uid)
+                return self._search([('value', operator, int(name.split(':')[1]))], limit=limit, order=order)
             else:
                 return []
 
@@ -71,9 +71,9 @@ class One2ManyChild(models.Model):
         return [(record.id, "%s:%s" % (self._name, record.value)) for record in self]
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         if isinstance(name, str) and name.split(':')[0] == self._name:
-            return self._search([('value', operator, int(name.split(':')[1]))], limit=limit, order=order, access_rights_uid=name_get_uid)
+            return self._search([('value', operator, int(name.split(':')[1]))], limit=limit, order=order)
         else:
             return []
 
@@ -128,9 +128,9 @@ class Many2ManyChild(models.Model):
         return [(record.id, "%s:%s" % (self._name, record.value)) for record in self]
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
         if isinstance(name, str) and name.split(':')[0] == self._name:
-            return self._search([('value', operator, int(name.split(':')[1]))], limit=limit, order=order, access_rights_uid=name_get_uid)
+            return self._search([('value', operator, int(name.split(':')[1]))], limit=limit, order=order)
         else:
             return []
 

odoo/models.py

@@ -1694,12 +1694,10 @@ class BaseModel(metaclass=MetaModel):
         return self.browse(ids).sudo().name_get()
 
     @api.model
-    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None, name_get_uid=None):
-        """ _name_search(name='', domain=None, operator='ilike', limit=None, order=None, name_get_uid=None) -> ids
+    def _name_search(self, name, domain=None, operator='ilike', limit=None, order=None):
+        """ _name_search(name='', domain=None, operator='ilike', limit=None, order=None) -> ids
 
         Private implementation of name_search, returning ids or a :class:`Query` object.
-        It allows passing a dedicated user for the name_get part to solve some
-        access rights issues.
 
         No default is applied for parameters ``limit`` and ``order``.
         """
@@ -1711,7 +1709,7 @@ class BaseModel(metaclass=MetaModel):
         elif not (name == '' and operator in ('like', 'ilike')):
             aggregator = expression.AND if operator in expression.NEGATIVE_TERM_OPERATORS else expression.OR
             domain += aggregator([[(field_name, operator, name)] for field_name in search_fnames])
-        return self._search(domain, limit=limit, order=order, access_rights_uid=name_get_uid)
+        return self._search(domain, limit=limit, order=order)
 
     @api.model
     def _add_missing_default_values(self, values):