Web

No new fields.

• formatted_read_group(self, domain: DomainType, groupby: <expr>=(), aggregates: <expr>=(), having: DomainType=(), offset: int=0, limit: <expr>=None, order: <expr>=None) -> <expr>
  @api.model@api.readonly
  A method similar to :meth:`_read_group` but with all the formatting needed by the webclient. :param domain: :ref:`A search domain <reference/orm/domains>`. Use an empty list to match all records. :param groupby: list of groupby descriptions by which the records will be grouped. A groupby description is either a field (then it will be grouped by that field) or a string ``'<field>:<granularity>'``. Right now, the only supported granularities are: * ``day`` * ``week`` * ``month`` * ``quarter`` * ``year`` and they only make sense for date/datetime fields. Additionally integer date parts are also supported: * ``year_number`` * ``quarter_number`` * ``month_number`` * ``iso_week_number`` * ``day_of_year`` * ``day_of_month`` * ``day_of_week`` * ``hour_number`` * ``minute_number`` * ``second_number`` :param aggregates: list of aggregates specification. Each element is ``'<field>:<agg>'`` (aggregate field with aggregation function ``agg``). The possible aggregation functions are the ones provided by `PostgreSQL <https://www.postgresql.org/docs/current/static/functions-aggregate.html>`_, except ``count_distinct`` and ``array_agg_distinct`` with the expected meaning. :param having: A domain where the valid "fields" are the aggregates. :param offset: optional number of groups to skip :param limit: optional max number of groups to return :param order: optional ``order by`` specification, for overriding the natural sort ordering of the groups, see :meth:`~.search`. :return: list of dict such as ``[{'groupy_spec': value, ...}, ...]`` containing: * the groupby values: ``{groupby[i]: <value>}`` * the aggregate values: ``{aggregates[i]: <value>}`` * ``'__extra_domain'``: list of tuples specifying the group search criteria * ``'__fold'``: boolean if a fold_name is set on the comodel and read_group_expand is activated :raise AccessError: if user is not allowed to access requested information
• formatted_read_grouping_sets(self, domain: DomainType, grouping_sets: <expr>, aggregates: <expr>=(), *, order: <expr>=None) -> <expr>
  @api.model@api.readonly
  A method similar to :meth:`_read_grouping_set` but with all the formatting needed by the webclient. It is a multi groupby version of formatted_read_group allowing to have aggregates for different groupby specifications in a single SQL requests. :param domain: :ref:`A search domain <reference/orm/domains>`. Use an empty list to match all records. :param grouping_sets: list of list of groupby descriptions by which the records will be grouped. A groupby description is either a field (then it will be grouped by that field) or a string ``'<field>:<granularity>'``. Right now, the only supported granularities are: * ``day`` * ``week`` * ``month`` * ``quarter`` * ``year`` and they only make sense for date/datetime fields. Additionally integer date parts are also supported: * ``year_number`` * ``quarter_number`` * ``month_number`` * ``iso_week_number`` * ``day_of_year`` * ``day_of_month`` * ``day_of_week`` * ``hour_number`` * ``minute_number`` * ``second_number`` :param aggregates: list of aggregates specification. Each element is ``'<field>:<agg>'`` (aggregate field with aggregation function ``agg``). The possible aggregation functions are the ones provided by `PostgreSQL <https://www.postgresql.org/docs/current/static/functions-aggregate.html>`_, except ``count_distinct`` and ``array_agg_distinct`` with the expected meaning. :param order: optional ``order by`` specification, for overriding the natural sort ordering of the groups, see :meth:`~.search`. :return: list of list of dict such as ``[[{'groupy_spec': value, ...}, ...], ...]`` containing: * the groupby values: ``{groupby[i]: <value>}`` * the aggregate values: ``{aggregates[i]: <value>}`` * ``'__extra_domain'``: list of tuples specifying the group search criteria * ``'__fold'``: boolean if a fold_name is set on the comodel and read_group_expand is activated :raise AccessError: if user is not allowed to access requested information
• onchange(self, values: dict, field_names: <expr>, fields_spec: dict)
  Perform an onchange on the given fields, and return the result. :param values: dictionary mapping field names to values on the form view, giving the current state of modification :param field_names: names of the modified fields :param fields_spec: dictionary specifying the fields in the view, just like the one used by :meth:`web_read`; it is used to format the resulting values When creating a record from scratch, the client should call this with an empty list as ``field_names``. In that case, the method first adds default values to ``values``, computes the remaining fields, applies onchange methods to them, and return all the fields in ``fields_spec``. The result is a dictionary with two optional keys. The key ``"value"`` is used to return field values that should be modified on the caller. The corresponding value is a dict mapping field names to their value, in the format of :meth:`web_read`, except for x2many fields, where the value is a list of commands to be applied on the caller's field value. The key ``"warning"`` provides a warning message to the caller. The corresponding value is a dictionary like:: { "title": "Be careful!", # subject of message "message": "Blah blah blah.", # full warning message "type": "dialog", # how to display the warning }
• onchange_batch(self, values_list: <expr>, field_names: <expr>, fields_spec: dict) -> <expr>
  @api.model
  Apply onchange to a batch of new records. This method only supports new records, so ``self`` must be empty.
• read_progress_bar(self, domain: DomainType, group_by: str, progress_bar: <expr>) -> <expr>
  @api.model@api.readonly
  Get the data needed for all the kanban column progressbars. These are fetched alongside read_group operation. :param domain: the domain used in the kanban view to filter records :param group_by: the name of the field used to group records into kanban columns :param progress_bar: the ``<progressbar/>`` declaration attributes (field, colors, sum) :return: a dictionary mapping group_by values to dictionaries mapping progress bar field values to the related number of records
• search_panel_select_multi_range(self, field_name: str, **kwargs) -> <expr>
  @api.model
  Return possible values of the field field_name (case select="multi"), possibly with counters and groups. :param field_name: the name of a filter field; possible types are many2one, many2many, selection. :param kwargs: additional features :param category_domain: domain generated by categories. Default is ``[]``. :param comodel_domain: domain of field values (if relational) (this parameter is used in :meth:`_search_panel_range`). Default is ``[]``. :param enable_counters: whether to count records by value. Default is ``False``. :param expand: whether to return the full range of field values in ``comodel_domain`` or only the field image values. Default is ``False``. :param filter_domain: domain generated by filters. Default is ``[]``. :param group_by: extra field to read on comodel, to group comodel records. :param group_domain: dict, one domain for each activated group for the group_by (if any). Those domains are used to fech accurate counters for values in each group. Default is ``[]`` (many2one case) or ``None``. :param limit: integer, maximal number of values to fetch. Default is ``None`` (no limit). :param search_domain: base domain of search. Default is ``[]``. :return: :: { 'values': a list of possible values, each being a dict with keys 'id' (value), 'name' (value label), '__count' (how many records with that value), 'group_id' (value of group), set if a group_by has been provided, 'group_name' (label of group), set if a group_by has been provided } or an object with an error message when limit is defined and reached.
• search_panel_select_range(self, field_name: str, **kwargs) -> <expr>
  @api.model
  Return possible values of the field field_name (case select="one"), possibly with counters, and the parent field (if any and required) used to hierarchize them. :param field_name: the name of a field; of type many2one or selection. :param kwargs: additional features * category_domain: domain generated by categories. Default is ``[]``. * comodel_domain: domain of field values (if relational). Default is ``[]``. * enable_counters: whether to count records by value. Default is ``False``. * expand: whether to return the full range of field values in comodel_domain or only the field image values (possibly filtered and/or completed with parents if hierarchize is set). Default is ``False``. * filter_domain: domain generated by filters. Default is ``[]``. * hierarchize: determines if the categories must be displayed hierarchically (if possible). If set to true and ``_parent_name`` is set on the comodel field, the information necessary for the hierarchization will be returned. Default is ``True``. * limit: integer, maximal number of values to fetch. Default is ``None`` (no limit). * search_domain: base domain of search. Default is ``[]``. :return: :: { 'parent_field': parent field on the comodel of field, or False 'values': array of dictionaries containing some info on the records available on the comodel of the field 'field_name'. The display name, the __count (how many records with that value) and possibly parent_field are fetched. } or an object with an error message when limit is defined and is reached.
• web_name_search(self, name: str, specification: <expr>, domain: <expr>=None, operator: str='ilike', limit: int=100) -> <expr>
  @api.model@api.readonly
  Search for records that have a display name matching the given ``name`` pattern when compared with the given ``operator``, while also matching the optional search domain (``domain``). The result is a dictionnary formatted according to the given ``specification``. Unlike the standard ``name_search()`` method, ``web_name_search()`` can traverse relational fields to fetch nested field values in a single call. Example:: records.web_name_search( name = "Note", operator = "ilike", specification = { 'display_name': {}, 'author_id': { 'fields': { 'display_name': {} } }, 'line_ids': { 'fields': { 'name': {} }, 'limit': 5, 'order': 'sequence asc' } } ) >>> [{ 'id': 1, 'display_name': 'Note G', 'author_id': { 'id': 42, 'display_name': 'Ada Lovelace' }, 'line_ids': [ {'id': 10, 'name': 'Intro'}, {'id': 11, 'name': 'Body'} ], '__formatted_display_name': "Note G" }] :param name: the name pattern to match :param domain: search domain specifying further restrictions :param operator: domain operator for matching ``name``, such as ``'like'`` or ``'='``. :param limit: max number of records to return :param specification: A dictionary defining the fields to read. The keys are field names, and the values are configuration dictionaries. Passing an empty dictionary as a value simply reads the field's value. Supported keys inside a field's configuration dictionary: * ``fields`` (dict): Nested specification for relational or property fields. * ``context`` (dict): Context to apply when evaluating the relational field. * ``limit`` (int): Maximum number of records to fetch (for x2many fields). * ``order`` (str): Sorting order to apply (for x2many fields). :return: A list of dictionaries representing the requested records.
• web_override_translations(self, values: <expr>) -> None
  This method is used to override all the modal translations of the given fields with the provided value for each field. :param values: dictionary of the translations to apply for each field name ex: ``{ "field_name": "new_value" }``
• web_read(self, specification: <expr>) -> <expr>
  @api.readonly
  Read the requested fields for the records in ``self``, returning their values as a list of dicts according to the provided specification. Unlike the standard :meth:`read()` method, ``web_read()`` can traverse relational fields to fetch nested field values in a single call. Example:: records.web_read({ 'display_name': {}, 'author_id': { 'fields': { 'display_name': {} } }, 'line_ids': { 'fields': { 'name': {} }, 'limit': 5, 'order': 'sequence asc' } }) >>> [{ 'id': 1, 'display_name': 'Note G', 'author_id': { 'id': 42, 'display_name': 'Ada Lovelace' }, 'line_ids': [ {'id': 10, 'name': 'Intro'}, {'id': 11, 'name': 'Body'} ] }] :param specification: A dictionary defining the fields to read. The keys are field names, and the values are configuration dictionaries. Passing an empty dictionary as a value simply reads the field's value. Supported keys inside a field's configuration dictionary: * ``fields`` (dict): Nested specification for relational or property fields. * ``context`` (dict): Context to apply when evaluating the relational field. * ``limit`` (int): Maximum number of records to fetch (for x2many fields). * ``order`` (str): Sorting order to apply (for x2many fields). :return: A list of dictionaries representing the requested records.
• web_read_group(self, domain: DomainType, groupby: <expr>, aggregates: <expr>=(), limit: <expr>=None, offset: int=0, order: <expr>=None, *, auto_unfold: bool=False, opening_info: <expr>=None, unfold_read_specification: <expr>=None, unfold_read_default_limit: <expr>=80, groupby_read_specification: <expr>=None) -> <expr>
  @api.model@api.readonly
  Serve as the primary method for loading grouped data in list and kanban views. This method wraps :meth:`~.formatted_read_group` to return both the grouped data and the total number of groups matching the search domain. It also conditionally opens (unfolds) groups based on the `auto_unfold` parameter and the `__fold` key returned by :meth:`~.formatted_read_group`. A group is considered "open" if it contains a `__records` or `__groups` key. - `__records`: The result of a :meth:`~.web_search_read` call for the group. - `__groups`: The results of subgroupings. :param domain: :ref:`A search domain <reference/orm/domains>`. :param groupby: A list of groupby specification at each level, see :meth:`~.formatted_read_group`. :param aggregates: A list of aggregate specifications. see :meth:`~.formatted_read_group` :param limit: The maximum number of top-level groups to return. see :meth:`~.formatted_read_group` :param offset: The offset for the top-level groups. see :meth:`~.formatted_read_group` :param order: A sort string, as used in :meth:`~.search` :param auto_unfold: If `True`, automatically unfolds the first 10 groups according to their `__fold` key, if present; otherwise, it is unfolded by default. This is typically `True` for kanban views and `False` for list views. :param opening_info: The state of currently opened groups, used for reloading. :: opening_info = [{ "value": raw_value_groupby, "folded": True or False, ["offset": int,] # present if unfolded ["limit": int,] # present if unfolded ["progressbar_domain": progressbar_domain,] # present if unfolded, e.g., when clicking on a progress bar section ["groups": <opening_info>,] # present if unfolded }] :param unfold_read_specification: The read specification for :meth:`~.web_read` when unfolding a group. :param unfold_read_default_limit: The default record limit to apply when unfolding a group. :param groupby_read_specification: The :meth:`~.web_read` specification for reading the records that are being grouped on. This is mainly for list views with <groupby> leaves. {<groupby_spec>: <read_specification>} :return: A dictionary with the following structure: :: { 'groups': <groups>, 'length': <total_group_count>, } Where <groups> is the result of :meth:`~.formatted_read_group`, but with an added `__groups` key for subgroups or a `__records` key for the result of :meth:`~.web_read` for records within the group.
• web_resequence(self, specification: <expr>, field_name: str='sequence', offset: int=0) -> <expr>
  Re-sequence a number of records in the model, by their ids. The re-sequencing starts at the first record of ``ids``, the sequence number starts at ``offset`` and is incremented by one after each record. The returning value is a read of the resequenced records with the specification given in the parameter. :param specification: specification for the read of the resequenced records :param field_name: field used for sequence specification, defaults to ``"sequence"`` :param offset: sequence number for first record in ``ids``, allows starting the resequencing from an arbitrary number, defaults to ``0``
• web_save(self, vals: ValuesType, specification: <expr>, next_id=None) -> <expr>
  Save the provided values to the current recordset, either by updating existing records or creating a new one if the recordset is empty. After saving, fetch and return the requested fields based on the provided specification. :param vals: fields to update and the value to set on them :param specification: A dictionary defining the fields to read. The keys are field names, and the values are configuration dictionaries. Passing an empty dictionary as a value simply reads the field's value. Supported keys inside a field's configuration dictionary: * ``fields`` (dict): Nested specification for relational or property fields. * ``context`` (dict): Context to apply when evaluating the relational field. * ``limit`` (int): Maximum number of records to fetch (for x2many fields). * ``order`` (str): Sorting order to apply (for x2many fields). :param next_id: An optional record ID to browse and return instead of the currently saved record. :return: A list of dictionaries representing the requested records.
• web_save_multi(self, vals_list: <expr>, specification: <expr>) -> <expr>
  Save the provided list of values to the current recordset, either by updating existing records or creating a new one if the recordset is empty. After saving, fetch and return the requested fields based on the provided specification. :param vals_list: values for the model's fields, as a list of dictionaries :param specification: A dictionary defining the fields to read. The keys are field names, and the values are configuration dictionaries. Passing an empty dictionary as a value simply reads the field's value. Supported keys inside a field's configuration dictionary: * ``fields`` (dict): Nested specification for relational or property fields. * ``context`` (dict): Context to apply when evaluating the relational field. * ``limit`` (int): Maximum number of records to fetch (for x2many fields). * ``order`` (str): Sorting order to apply (for x2many fields). :return: A list of dictionaries representing the requested records.
• web_search_read(self, domain: DomainType, specification: <expr>, offset: int=0, limit: <expr>=None, order: <expr>=None, count_limit: <expr>=None) -> <expr>
  @api.model@api.readonly
  Perform a search followed by a structured read. Unlike the standard :meth:`search_read()`, ``web_search_read()`` can traverse relational fields to fetch nested field values in a single call. :param domain: search domain specifying further restrictions :param offset: number of results to ignore (default: none) :param limit: maximum number of records to return (default: all) :param order: sort string :param specification: A dictionary defining the fields to read. The keys are field names, and the values are configuration dictionaries. Passing an empty dictionary as a value simply reads the field's value. Supported keys inside a field's configuration dictionary: * ``fields`` (dict): Nested specification for relational or property fields. * ``context`` (dict): Context to apply when evaluating the relational field. * ``limit`` (int): Maximum number of records to fetch (for x2many fields). * ``order`` (str): Sorting order to apply (for x2many fields). :return: A dictionary containing a 'length' key containing the number of records and a 'records' key containing a list of records.
• web_unlink(self) -> <expr>
  Delete the records in ``self``, the way the web client's own delete flows do it. This is deliberately a separate method from :meth:`~.unlink`, called only by the web client, so that the error-recovery below never runs for internal ``unlink()`` calls made by other server-side code. If deleting ``self`` in one go is blocked by a foreign key/RESTRICT violation, pinpoint exactly which records of ``self`` are the actual problem by retrying the deletion record by record (each attempt rolled back regardless of its outcome, so nothing is ever partially deleted), then raise a :class:`UnlinkBlockedError` enriched with that information - the blocking model's display name, whether the records can be archived instead, and which of them are actually blocked.

• company_details Html
  default=_default_company_details readonly=False related='company_id.company_details'
• company_id Many2one → res.company
  default=<expr> required=True args: 'res.company'
• country_id Many2one
  readonly=True related='company_id.country_id'
• custom_colors Boolean
  compute='_compute_custom_colors' readonly=False
• email Char
  readonly=True related='company_id.email'
• external_report_layout_id Many2one
  readonly=False related='company_id.external_report_layout_id'
• font Selection
  readonly=False related='company_id.font'
• is_company_details_empty Boolean
  compute='_compute_empty_company_details'
• logo Binary
  readonly=False related='company_id.logo'
• logo_primary_color Char
  compute='_compute_logo_colors'
• logo_secondary_color Char
  compute='_compute_logo_colors'
• name Char
  readonly=True related='company_id.name'
• paperformat_id Many2one
  readonly=False related='company_id.paperformat_id'
• partner_id Many2one
  readonly=True related='company_id.partner_id'
• phone Char
  readonly=True related='company_id.phone'
• preview Html
  compute='_compute_preview' sanitize=False
• preview_logo Binary
  related='logo' string='Preview logo'
• primary_color Char
  readonly=False related='company_id.primary_color'
• report_footer Html
  default=_default_report_footer readonly=False related='company_id.report_footer'
• report_header Html
  readonly=False related='company_id.report_header'
• report_layout_id Many2one → report.layout
  args: 'report.layout'
• report_tables_id Selection
  readonly=False related='company_id.report_tables_id' required=True
• secondary_color Char
  readonly=False related='company_id.secondary_color'
• vat Char
  readonly=True related='company_id.vat'
• website Char
  readonly=True related='company_id.website'

• document_layout_save(self)
• extract_image_primary_secondary_colors(self, logo, white_threshold=225, mitigate=175)
  @api.model
  Identifies dominant colors First resizes the original image to improve performance, then discards transparent colors and white-ish colors, then calls the averaging method twice to evaluate both primary and secondary colors. :param logo: logo to process :param white_threshold: arbitrary value defining the maximum value a color can reach :param mitigate: arbitrary value defining the maximum value a band can reach :return: a 2-value tuple with hex values of primary and secondary colors

No new fields.

• web_create_image_variants(self, variants)
  @api.model
  Create linked image variants in batch using `create_unique`.

No new fields.

• color_scheme(self)
• get_currencies(self)
  @deprecated("Deprecated since 19.0, use get_all_currencies on 'res.currency'")
• get_frontend_session_info(self)
  @api.model
• is_a_bot(cls)
  @classmethod
• lazy_session_info(self)
  @api.model
• session_info(self)
• webclient_rendering_context(self)

No new fields.

• display_name_for(self, models)
  @api.model
  Returns the display names from provided models which the current user can access. The result is the same whether someone tries to access an inexistent model or a model they cannot access. :models list(str): list of technical model names to lookup (e.g. `["res.partner"]`) :return: list of dicts of the form `{ "model", "display_name" }` (e.g. `{ "model": "res_partner", "display_name": "Contact"}`)
• get_available_models(self)
  @api.model
  Return the list of models the current user has access to, with their corresponding display name.

No new fields.

• record_to_html(self, record, field_name, options)
  @api.model

No new fields.

No public methods.

No new fields.

• load_web_menus(self, debug)
  Loads all menu items (all applications and their sub-menus) and processes them to be used by the webclient. Mainly, it associates with each application (top level menu) the action of its first child menu that is associated with an action (recursively), i.e. with the action to execute when the opening the app. :return: the menus (including the images in Base64)

No new fields.

• get_view_info(self)

No new fields.

• get_properties_base_definition(self, model_name, field_name)
  @api.model
  Return the base properties definition if we can read the model.

No new fields.

• create(self, vals_list)
  @api.model_create_multi
• write(self, vals)

• web_app_name Char
  config_parameter='web.web_app_name' args: 'Web App Name'

No public methods.

No new fields.

No public methods.

No new fields.

• name_search(self, name='', domain=None, operator='ilike', limit=100)
  @api.model

• embedded_actions_config_ids One2many → res.users.settings.embedded.action
  args: 'res.users.settings.embedded.action', 'user_setting_id'

• get_embedded_actions_settings(self)
• set_embedded_actions_setting(self, action_id, res_id, vals)

• action_id Many2one → ir.actions.act_window
  export_string_translation=False ondelete='cascade' required=True args: 'ir.actions.act_window'
• embedded_actions_order Char
  export_string_translation=False args: 'List order of embedded action ids'
• embedded_actions_visibility Char
  export_string_translation=False args: 'List visibility of embedded actions ids'
• embedded_visibility Boolean
  export_string_translation=False args: 'Is top bar visible'
• res_id Integer
  export_string_translation=False
• res_model Char
  export_string_translation=False required=True
• user_setting_id Many2one → res.users.settings
  export_string_translation=False index='btree_not_null' ondelete='cascade' required=True args: 'res.users.settings'

No public methods.