def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None): args = args or [] if self.env.context.get('country_id'): args = expression.AND([ args, [('country_id', '=', self.env.context.get('country_id'))] ]) if operator == 'ilike' and not (name or '').strip(): first_domain = [] domain = [] else: first_domain = [('code', '=ilike', name)] domain = [('name', operator, name)] first_state_ids = self._search( expression.AND([first_domain, args]), limit=limit, access_rights_uid=name_get_uid) if first_domain else [] state_ids = first_state_ids + [ state_id for state_id in self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid) if not state_id in first_state_ids ] return self.browse(state_ids).name_get()
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None): if operator not in ('ilike', 'like', '=', '=like', '=ilike'): return super(AccountAnalyticAccount, self)._name_search(name, args, operator, limit, name_get_uid=name_get_uid) args = args or [] if operator == 'ilike' and not (name or '').strip(): domain = [] else: # search by partner separately because auto_join field can break searches partner_domain = [('partner_id.name', operator, name)] ids_partner = self._search(expression.AND([partner_domain, args]), limit=limit, access_rights_uid=name_get_uid) domain = [ '|', '|', ('code', operator, name), ('name', operator, name), ('id', 'in', ids_partner) ] analytic_account_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid) return self.browse(analytic_account_ids).name_get()
def render_latest_posts(self, template, domain, limit=None, order='published_date desc'): dom = expression.AND([[('website_published', '=', True), ('post_date', '<=', fields.Datetime.now())], request.website.website_domain()]) if domain: dom = expression.AND([dom, domain]) posts = request.env['blog.post'].search(dom, limit=limit, order=order) return request.website.viewref(template).render({'posts': posts})
def _gather(self, product_id, location_id, lot_id=None, package_id=None, owner_id=None, strict=False): removal_strategy = self._get_removal_strategy(product_id, location_id) removal_strategy_order = self._get_removal_strategy_order(removal_strategy) domain = [ ('product_id', '=', product_id.id), ] if not strict: if lot_id: domain = expression.AND([['|', ('lot_id', '=', lot_id.id), ('lot_id', '=', False)], domain]) if package_id: domain = expression.AND([[('package_id', '=', package_id.id)], domain]) if owner_id: domain = expression.AND([[('owner_id', '=', owner_id.id)], domain]) domain = expression.AND([[('location_id', 'child_of', location_id.id)], domain]) else: domain = expression.AND([['|', ('lot_id', '=', lot_id.id), ('lot_id', '=', False)] if lot_id else [('lot_id', '=', False)], domain]) domain = expression.AND([[('package_id', '=', package_id and package_id.id or False)], domain]) domain = expression.AND([[('owner_id', '=', owner_id and owner_id.id or False)], domain]) domain = expression.AND([[('location_id', '=', location_id.id)], domain]) # Copy code of _search for special NULLS FIRST/LAST order self.sudo(self._uid).check_access_rights('read') query = self._where_calc(domain) self._apply_ir_rules(query, 'read') from_clause, where_clause, where_clause_params = query.get_sql() where_str = where_clause and (" WHERE %s" % where_clause) or '' query_str = 'SELECT "%s".id FROM ' % self._table + from_clause + where_str + " ORDER BY "+ removal_strategy_order self._cr.execute(query_str, where_clause_params) res = self._cr.fetchall() # No uniquify list necessary as auto_join is not applied anyways... quants = self.browse([x[0] for x in res]) quants = quants.sorted(lambda q: not q.lot_id) return quants
def _get_assets_domain_for_already_processed_css(self, assets): res = super(AssetsBundleMultiWebsite, self)._get_assets_domain_for_already_processed_css(assets) current_website = self.env['website'].get_current_website( fallback=False) res = expression.AND([res, current_website.website_domain()]) return res
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None): # TDE FIXME: currently overriding the domain; however as it includes a # search on a m2o and one on a m2m, probably this will quickly become # difficult to compute - check if performance optimization is required if name and operator in ('=', 'ilike', '=ilike', 'like', '=like'): args = args or [] domain = [ '|', ('attribute_id', operator, name), ('value_ids', operator, name) ] attribute_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid) return self.browse(attribute_ids).name_get() return super(ProductTemplateAttributeLine, self)._name_search(name=name, args=args, operator=operator, limit=limit, name_get_uid=name_get_uid)
def _domain_move_lines_for_reconciliation(self, st_line, aml_accounts, partner_id, excluded_ids=None, search_str=False): def to_int(val): try: return int(val) except (ValueError, TypeError): return None domain = super()._domain_move_lines_for_reconciliation( st_line, aml_accounts, partner_id, excluded_ids=excluded_ids, search_str=search_str) acc_props = ( "property_stock_account_input", "property_stock_account_output", "property_stock_account_input_categ_id", "property_stock_account_output_categ_id", ) acc_ids = [ (acc["value_reference"] or "").split(",")[-1] for acc in self.env["ir.property"].sudo().search([( "name", "in", acc_props), ("value_reference", "!=", False)]).read(["value_reference"]) if to_int((acc["value_reference"] or "").split(",")[-1]) ] if acc_ids: domain = expression.AND( [domain, [("account_id.id", "not in", acc_ids)]]) return domain
def _get_moves_to_assign_domain(self, company_id): moves_domain = [ ('state', 'in', ['confirmed', 'partially_available']), ('product_uom_qty', '!=', 0.0) ] if company_id: moves_domain = expression.AND([[('company_id', '=', company_id)], moves_domain]) return moves_domain
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None): """ search full name and barcode """ args = args or [] if operator == 'ilike' and not (name or '').strip(): domain = [] else: domain = ['|', ('barcode', operator, name), ('complete_name', operator, name)] location_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid) return self.browse(location_ids).name_get()
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None): domain = args or [] cars = self._search(expression.AND( [domain, [('name', operator, name)]]), limit=limit, access_rights_uid=name_get_uid) cars += self._search(expression.AND( [domain, [('driver_id.name', operator, name)]]), limit=limit, access_rights_uid=name_get_uid) rec = self._search([('id', 'in', cars)], limit=limit, access_rights_uid=name_get_uid) return self.browse(rec).name_get()
def get_website_translations(self, lang, mods=None): Modules = request.env['ir.module.module'].sudo() IrHttp = request.env['ir.http'].sudo() domain = IrHttp._get_translation_frontend_modules_domain() modules = Modules.search( expression.AND([domain, [('state', '=', 'installed')]]) ).mapped('name') if mods: modules += mods return WebClient().translations(mods=modules, lang=lang)
def _get_inheriting_views_arch_domain(self, view_id, model): domain = super(View, self)._get_inheriting_views_arch_domain(view_id, model) current_website = self._get_inheriting_views_arch_website(view_id) website_views_domain = current_website.website_domain() # when rendering for the website we have to include inactive views # we will prefer inactive website-specific views over active generic ones if current_website: domain = [leaf for leaf in domain if 'active' not in leaf] return expression.AND([website_views_domain, domain])
def _search_rule(self, route_ids, product_id, warehouse_id, domain): """ First find a rule among the ones defined on the procurement group, then try on the routes defined for the product, finally fallback on the default behavior """ if warehouse_id: domain = expression.AND([['|', ('warehouse_id', '=', warehouse_id.id), ('warehouse_id', '=', False)], domain]) Rule = self.env['stock.rule'] res = self.env['stock.rule'] if route_ids: res = Rule.search(expression.AND([[('route_id', 'in', route_ids.ids)], domain]), order='route_sequence, sequence', limit=1) if not res: product_routes = product_id.route_ids | product_id.categ_id.total_route_ids if product_routes: res = Rule.search(expression.AND([[('route_id', 'in', product_routes.ids)], domain]), order='route_sequence, sequence', limit=1) if not res and warehouse_id: warehouse_routes = warehouse_id.route_ids if warehouse_routes: res = Rule.search(expression.AND([[('route_id', 'in', warehouse_routes.ids)], domain]), order='route_sequence, sequence', limit=1) return res
def _compute_domain(self, model_name, mode="read"): if mode not in self._MODES: raise ValueError('Invalid mode: %r' % (mode, )) if self._uid == SUPERUSER_ID: return None query = """ SELECT r.id FROM ir_rule r JOIN ir_model m ON (r.model_id=m.id) WHERE m.model=%s AND r.active AND r.perm_{mode} AND (r.id IN (SELECT rule_group_id FROM rule_group_rel rg JOIN res_groups_users_rel gu ON (rg.group_id=gu.gid) WHERE gu.uid=%s) OR r.global) """.format(mode=mode) self._cr.execute(query, (model_name, self._uid)) rule_ids = [row[0] for row in self._cr.fetchall()] if not rule_ids: return [] # browse user and rules as SUPERUSER_ID to avoid access errors! eval_context = self._eval_context() user_groups = self.env.user.groups_id global_domains = [] # list of domains group_domains = [] # list of domains for rule in self.browse(rule_ids).sudo(): # evaluate the domain for the current user dom = safe_eval(rule.domain_force, eval_context) if rule.domain_force else [] dom = expression.normalize_domain(dom) if not rule.groups: global_domains.append(dom) elif rule.groups & user_groups: group_domains.append(dom) # combine global domains and group domains if not group_domains: return expression.AND(global_domains) return expression.AND(global_domains + [expression.OR(group_domains)])
def get_mention_suggestions(self, search, limit=8): """ Return 'limit'-first partners' id, name and email such that the name or email matches a 'search' string. Prioritize users, and then extend the research to all partners. """ search_dom = expression.OR([[('name', 'ilike', search)], [('email', 'ilike', search)]]) search_dom = expression.AND([[('active', '=', True)], search_dom]) fields = ['id', 'name', 'email'] # Search users domain = expression.AND([[('user_ids.id', '!=', False), ('user_ids.active', '=', True)], search_dom]) users = self.search_read(domain, fields, limit=limit) # Search partners if less than 'limit' users found partners = [] if len(users) < limit: partners = self.search_read(search_dom, fields, limit=limit) # Remove duplicates partners = [ p for p in partners if not len([u for u in users if u['id'] == p['id']]) ] return [users, partners]
def portal_message_fetch(self, res_model, res_id, domain=False, limit=10, offset=0, **kw): if not domain: domain = [] # Only search into website_message_ids, so apply the same domain to perform only one search # extract domain from the 'website_message_ids' field field_domain = request.env[res_model]._fields['website_message_ids'].domain if callable(field_domain): field_domain = field_domain(request.env[res_model]) domain = expression.AND([domain, field_domain, [('res_id', '=', res_id)]]) # Check access Message = request.env['mail.message'] if kw.get('token'): access_as_sudo = _has_token_access(res_model, res_id, token=kw.get('token')) if not access_as_sudo: # if token is not correct, raise Forbidden raise Forbidden() # Non-employee see only messages with not internal subtype (aka, no internal logs) if not request.env['res.users'].has_group('base.group_user'): domain = expression.AND([Message._non_employee_message_domain(), domain]) Message = request.env['mail.message'].sudo() return { 'messages': Message.search(domain, limit=limit, offset=offset).portal_message_format(), 'message_count': Message.search_count(domain) }
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None): args = args or [] domain = [] if name: domain = [ '|', ('name', operator, name), ('reference', operator, name) ] purchase_bills_union_ids = self._search(expression.AND([domain, args]), limit=limit, access_rights_uid=name_get_uid) return self.browse(purchase_bills_union_ids).name_get()
def _compute_debit_credit_balance(self): Curr = self.env['res.currency'] analytic_line_obj = self.env['account.analytic.line'] domain = [('account_id', 'in', self.ids)] if self._context.get('from_date', False): domain.append(('date', '>=', self._context['from_date'])) if self._context.get('to_date', False): domain.append(('date', '<=', self._context['to_date'])) if self._context.get('tag_ids'): tag_domain = expression.OR([[('tag_ids', 'in', [tag])] for tag in self._context['tag_ids']]) domain = expression.AND([domain, tag_domain]) if self._context.get('company_ids'): domain.append(('company_id', 'in', self._context['company_ids'])) user_currency = self.env.user.company_id.currency_id credit_groups = analytic_line_obj.read_group( domain=domain + [('amount', '>=', 0.0)], fields=['account_id', 'currency_id', 'amount'], groupby=['account_id', 'currency_id'], lazy=False, ) data_credit = defaultdict(float) for l in credit_groups: data_credit[l['account_id'][0]] += Curr.browse( l['currency_id'][0])._convert(l['amount'], user_currency, self.env.user.company_id, fields.Date.today()) debit_groups = analytic_line_obj.read_group( domain=domain + [('amount', '<', 0.0)], fields=['account_id', 'currency_id', 'amount'], groupby=['account_id', 'currency_id'], lazy=False, ) data_debit = defaultdict(float) for l in debit_groups: data_debit[l['account_id'][0]] += Curr.browse( l['currency_id'][0])._convert(l['amount'], user_currency, self.env.user.company_id, fields.Date.today()) for account in self: account.debit = abs(data_debit.get(account.id, 0.0)) account.credit = data_credit.get(account.id, 0.0) account.balance = account.credit - account.debit
def _get_rule(self, product_id, location_id, values): """ Find a pull rule for the location_id, fallback on the parent locations if it could not be found. """ result = False location = location_id while (not result) and location: domain = ['&', ('location_id', '=', location.id), ('action', '!=', 'push')] # In case the method is called by the superuser, we need to restrict the rules to the # ones of the company. This is not useful as a regular user since there is a record # rule to filter out the rules based on the company. if self.env.user._is_superuser() and values.get('company_id'): domain_company = ['|', ('company_id', '=', False), ('company_id', 'child_of', values['company_id'].ids)] domain = expression.AND([domain, domain_company]) result = self._search_rule(values.get('route_ids', False), product_id, values.get('warehouse_id', False), domain) location = location.location_id return result
def _name_search(self, name, args=None, operator='ilike', limit=100, name_get_uid=None): args = args or [] if name: action_ids = self._search(expression.AND([[('action_id', operator, name)], args]), limit=limit, access_rights_uid=name_get_uid) return self.browse(action_ids).name_get() return super(IrActionsTodo, self)._name_search(name, args=args, operator=operator, limit=limit, name_get_uid=name_get_uid)
def _search(self, args, offset=0, limit=None, order=None, count=False, access_rights_uid=None): """ Override that adds specific access rights of mail.message, to restrict messages to published messages for public users. """ if self.user_has_groups('base.group_public'): args = expression.AND([[('website_published', '=', True)], list(args)]) return super(MailMessage, self)._search(args, offset=offset, limit=limit, order=order, count=count, access_rights_uid=access_rights_uid)
def action_see_days_allocated(self): self.ensure_one() action = self.env.ref( 'hr_holidays.hr_leave_allocation_action_all').read()[0] domain = [ ('holiday_status_id', 'in', self.ids), ('holiday_type', '!=', 'employee'), ] domain2 = [ '|', ('date_from', '>=', fields.Datetime.to_string(datetime.datetime.now().replace( month=1, day=1, hour=0, minute=0, second=0, microsecond=0))), ('date_from', '=', False), ] action['domain'] = expression.AND([domain, domain2]) action['context'] = { 'default_holiday_type': 'department', 'default_holiday_status_id': self.ids[0], } return action
def _change_model_id(self): """Force domain for the `field_id` and `field_date_id` fields""" if not self.model_id: return { 'domain': { 'field_id': expression.FALSE_DOMAIN, 'field_date_id': expression.FALSE_DOMAIN } } model_fields_domain = [('store', '=', True), '|', ('model_id', '=', self.model_id.id), ('model_id', 'in', self.model_id.inherited_model_ids.ids)] model_date_fields_domain = expression.AND([[ ('ttype', 'in', ('date', 'datetime')) ], model_fields_domain]) return { 'domain': { 'field_id': model_fields_domain, 'field_date_id': model_date_fields_domain } }
def _compute_group_days_allocation(self): domain = [ ('holiday_status_id', 'in', self.ids), ('holiday_type', '!=', 'employee'), ('state', '=', 'validate'), ] domain2 = [ '|', ('date_from', '>=', fields.Datetime.to_string(datetime.datetime.now().replace( month=1, day=1, hour=0, minute=0, second=0, microsecond=0))), ('date_from', '=', False), ] grouped_res = self.env['hr.leave.allocation'].read_group( expression.AND([domain, domain2]), ['holiday_status_id', 'number_of_days'], ['holiday_status_id'], ) grouped_dict = dict( (data['holiday_status_id'][0], data['number_of_days']) for data in grouped_res) for allocation in self: allocation.group_days_allocation = grouped_dict.get( allocation.id, 0)
def portal_order_page(self, order_id, report_type=None, access_token=None, message=False, download=False, **kw): try: order_sudo = self._document_check_access('sale.order', order_id, access_token=access_token) except (AccessError, MissingError): return request.redirect('/my') if report_type in ('html', 'pdf', 'text'): return self._show_report(model=order_sudo, report_type=report_type, report_ref='sale.action_report_saleorder', download=download) # use sudo to allow accessing/viewing orders for public user # only if he knows the private token # Log only once a day if order_sudo: now = fields.Date.today().isoformat() session_obj_date = request.session.get('view_quote_%s' % order_sudo.id) if isinstance(session_obj_date, date): session_obj_date = session_obj_date.isoformat() if session_obj_date != now and request.env.user.share and access_token: request.session['view_quote_%s' % order_sudo.id] = now body = _('Quotation viewed by customer') _message_post_helper( res_model='sale.order', res_id=order_sudo.id, message=body, token=order_sudo.access_token, message_type='notification', subtype="mail.mt_note", partner_ids=order_sudo.user_id.sudo().partner_id.ids) values = { 'sale_order': order_sudo, 'message': message, 'token': access_token, 'return_url': '/shop/payment/validate', 'bootstrap_formatting': True, 'partner_id': order_sudo.partner_id.id, 'report_type': 'html', } if order_sudo.company_id: values['res_company'] = order_sudo.company_id if order_sudo.has_to_be_paid(): domain = expression.AND( [[ '&', ('website_published', '=', True), ('company_id', '=', order_sudo.company_id.id) ], [ '|', ('specific_countries', '=', False), ('country_ids', 'in', [order_sudo.partner_id.country_id.id]) ]]) acquirers = request.env['payment.acquirer'].sudo().search(domain) values['acquirers'] = acquirers.filtered(lambda acq: ( acq.payment_flow == 'form' and acq.view_template_id) or ( acq.payment_flow == 's2s' and acq. registration_view_template_id)) values['pms'] = request.env['payment.token'].search([ ('partner_id', '=', order_sudo.partner_id.id) ]) if order_sudo.state in ('draft', 'sent', 'cancel'): history = request.session.get('my_quotations_history', []) else: history = request.session.get('my_orders_history', []) values.update(get_records_pager(history, order_sudo)) return request.render('sale.sale_order_portal_template', values)
def open_action(self): """return action based on type for related journals""" action_name = self._context.get('action_name', False) if not action_name: if self.type == 'bank': action_name = 'action_bank_statement_tree' elif self.type == 'cash': action_name = 'action_view_bank_statement_tree' elif self.type == 'sale': action_name = 'action_invoice_tree1' use_domain = expression.AND([ self.env.context.get('use_domain', []), [('journal_id', '=', self.id)] ]) self = self.with_context(use_domain=use_domain) elif self.type == 'purchase': action_name = 'action_vendor_bill_template' use_domain = expression.AND([ self.env.context.get('use_domain', []), [('journal_id', '=', self.id)] ]) self = self.with_context(use_domain=use_domain) else: action_name = 'action_move_journal_line' _journal_invoice_type_map = { ('sale', None): 'out_invoice', ('purchase', None): 'in_invoice', ('sale', 'refund'): 'out_refund', ('purchase', 'refund'): 'in_refund', ('bank', None): 'bank', ('cash', None): 'cash', ('general', None): 'general', } invoice_type = _journal_invoice_type_map[( self.type, self._context.get('invoice_type'))] ctx = self._context.copy() ctx.pop('group_by', None) ctx.update({ 'journal_type': self.type, 'default_journal_id': self.id, 'default_type': invoice_type, 'type': invoice_type }) [action] = self.env.ref('account.%s' % action_name).read() if not self.env.context.get('use_domain'): ctx['search_default_journal_id'] = self.id action['context'] = ctx action['domain'] = self._context.get('use_domain', []) account_invoice_filter = self.env.ref( 'account.view_account_invoice_filter', False) if action_name in [ 'action_invoice_tree1', 'action_vendor_bill_template' ]: action[ 'search_view_id'] = account_invoice_filter and account_invoice_filter.id or False if action_name in [ 'action_bank_statement_tree', 'action_view_bank_statement_tree' ]: action['views'] = False action['view_id'] = False if self.type == 'purchase': new_help = self.env['account.invoice'].with_context( ctx).complete_empty_list_help() action.update({'help': (action.get('help') or '') + new_help}) return action
def _get_moves_to_assign_domain(self, company_id): domain = super(ProcurementGroup, self)._get_moves_to_assign_domain(company_id) domain = expression.AND([domain, [('production_id', '=', False)]]) return domain
def _non_employee_message_domain(self): domain = super(MailMessage, self)._non_employee_message_domain() return expression.AND([domain, [('website_published', '=', True)]])