odoo Model字段的參數

odoo Model字段的參數

class Field(object):
    """ The field descriptor contains the field definition, and manages accesses
        and assignments of the corresponding field on records. The following
        attributes may be provided when instanciating a field:

        :param string: the label of the field seen by users (string); if not
            set, the ORM takes the field name in the class (capitalized).

        :param help: the tooltip of the field seen by users (string)

        :param readonly: whether the field is readonly (boolean, by default ``False``)

        :param required: whether the value of the field is required (boolean, by
            default ``False``)

        :param index: whether the field is indexed in database (boolean, by
            default ``False``)

        :param default: the default value for the field; this is either a static
            value, or a function taking a recordset and returning a value; use
            ``default=None`` to discard default values for the field

        :param states: a dictionary mapping state values to lists of UI attribute-value
            pairs; possible attributes are: 'readonly', 'required', 'invisible'.
            Note: Any state-based condition requires the ``state`` field value to be
            available on the client-side UI. This is typically done by including it in
            the relevant views, possibly made invisible if not relevant for the
            end-user.

        :param groups: comma-separated list of group xml ids (string); this
            restricts the field access to the users of the given groups only

        :param bool copy: whether the field value should be copied when the record
            is duplicated (default: ``True`` for normal fields, ``False`` for
            ``one2many`` and computed fields, including property fields and
            related fields)

        :param string oldname: the previous name of this field, so that ORM can rename
            it automatically at migration

        .. _field-computed:

        .. rubric:: Computed fields

        One can define a field whose value is computed instead of simply being
        read from the database. The attributes that are specific to computed
        fields are given below. To define such a field, simply provide a value
        for the attribute ``compute``.

        :param compute: name of a method that computes the field

        :param inverse: name of a method that inverses the field (optional)

        :param search: name of a method that implement search on the field (optional)

        :param store: whether the field is stored in database (boolean, by
            default ``False`` on computed fields)

        :param compute_sudo: whether the field should be recomputed as superuser
            to bypass access rights (boolean, by default ``False``)

        The methods given for ``compute``, ``inverse`` and ``search`` are model
        methods. Their signature is shown in the following example::

            upper = fields.Char(compute='_compute_upper',
                                inverse='_inverse_upper',
                                search='_search_upper')

            @api.depends('name')
            def _compute_upper(self):
                for rec in self:
                    rec.upper = rec.name.upper() if rec.name else False

            def _inverse_upper(self):
                for rec in self:
                    rec.name = rec.upper.lower() if rec.upper else False

            def _search_upper(self, operator, value):
                if operator == 'like':
                    operator = 'ilike'
                return [('name', operator, value)]

        The compute method has to assign the field on all records of the invoked
        recordset. The decorator :meth:`odoo.api.depends` must be applied on
        the compute method to specify the field dependencies; those dependencies
        are used to determine when to recompute the field; recomputation is
        automatic and guarantees cache/database consistency. Note that the same
        method can be used for several fields, you simply have to assign all the
        given fields in the method; the method will be invoked once for all
        those fields.

        By default, a computed field is not stored to the database, and is
        computed on-the-fly. Adding the attribute ``store=True`` will store the
        field's values in the database. The advantage of a stored field is that
        searching on that field is done by the database itself. The disadvantage
        is that it requires database updates when the field must be recomputed.

        The inverse method, as its name says, does the inverse of the compute
        method: the invoked records have a value for the field, and you must
        apply the necessary changes on the field dependencies such that the
        computation gives the expected value. Note that a computed field without
        an inverse method is readonly by default.

        The search method is invoked when processing domains before doing an
        actual search on the model. It must return a domain equivalent to the
        condition: ``field operator value``.

        .. _field-related:

        .. rubric:: Related fields

        The value of a related field is given by following a sequence of
        relational fields and reading a field on the reached model. The complete
        sequence of fields to traverse is specified by the attribute

        :param related: sequence of field names

        Some field attributes are automatically copied from the source field if
        they are not redefined: ``string``, ``help``, ``readonly``, ``required`` (only
        if all fields in the sequence are required), ``groups``, ``digits``, ``size``,
        ``translate``, ``sanitize``, ``selection``, ``comodel_name``, ``domain``,
        ``context``. All semantic-free attributes are copied from the source
        field.

        By default, the values of related fields are not stored to the database.
        Add the attribute ``store=True`` to make it stored, just like computed
        fields. Related fields are automatically recomputed when their
        dependencies are modified.

        .. _field-company-dependent:

        .. rubric:: Company-dependent fields

        Formerly known as 'property' fields, the value of those fields depends
        on the company. In other words, users that belong to different companies
        may see different values for the field on a given record.

        :param company_dependent: whether the field is company-dependent (boolean)

        .. _field-sparse:

        .. rubric:: Sparse fields

        Sparse fields have a very small probability of being not null. Therefore
        many such fields can be serialized compactly into a common location, the
        latter being a so-called "serialized" field.

        :param sparse: the name of the field where the value of this field must
            be stored.

        .. _field-incremental-definition:

        .. rubric:: Incremental definition

        A field is defined as class attribute on a model class. If the model
        is extended (see :class:`~odoo.models.Model`), one can also extend
        the field definition by redefining a field with the same name and same
        type on the subclass. In that case, the attributes of the field are
        taken from the parent class and overridden by the ones given in
        subclasses.

        For instance, the second class below only adds a tooltip on the field
        ``state``::

            class First(models.Model):
                _name = 'foo'
                state = fields.Selection([...], required=True)

            class Second(models.Model):
                _inherit = 'foo'
                state = fields.Selection(help="Blah blah blah")

    """

1.基礎文件及目錄結構

在認識odoo ORM框架前，先介紹一下odoo中模塊目錄結構。
 

 

data：存放模塊預製數據
i18n：存放國際化文件
models：存放模型等py代碼
security：存放權限文件
views：存放視圖文件
__manifest__.py：該文件用於聲明該模塊，並指定一些模塊元數據。（odoo8時該文件爲__openerp__.py。）
 

# -*- coding: utf-8 -*-
{
    # name:模塊名稱
    'name': " test",
    # description:模塊描述
    'description': """
        自定義模塊
    """,
    # author:模塊做者（XXX公司或張三）
    'author': "Hu",
    # website:做者或公司網址
    'website': "http://weibo.com/hcw1202",
    # category:模塊分類
    'category': "test",
    # version:模塊版本
    'version': "版本",
    # depends:所依賴其餘模塊
    'depends': ["base","stock","sale"],
    # 模塊安裝時加載
    'data': [
        'security/權限文件.csv',
        'data/預製數據.xml',
        'views/視圖文件.xml',
    ],
    # 建立數據庫時勾選Load demonstration data後安裝該模塊加載演示數據
    'demo': [
       'data/演示數據.xml',
],
}

2.Model屬性

在/models下添加test.py文件

# -*- coding: utf-8 -*-
from odoo import models, api, fields, _
class Test(models.Model):
    # 模型惟一標識（對應數據表爲product_manage_product）
    _name = 'product_manage.product'
    # 數據顯示名稱，如設置則返回其指定的字段值
    _rec_name = 'test_field'
    # 字段
    test_field = fields.Char(string="字段名稱")

model屬性詳解：
_name：模型惟一標識，類非繼承父類時必須指定。
_rec_name：數據顯示名稱，如設置則返回其指定的字段值，不設置默認顯示字段爲name的字段值，如無name字段則顯示"模塊名,id"；詳見BaseModel.name_get方法。
_log_access：是否自動增長日誌字段（create_uid, create_date,write_uid, write_date）。默認爲True。
_auto：是否建立數據庫對象。默認爲True，詳見BaseModel._auto_init方法。
_table：數據庫對象名稱。缺省時數據庫對象名稱與_name指定值相同（.替換爲下劃線）。
_sequence：數據庫id字段的序列。默認自動建立序列。
_order：數據顯示排序。所指定值爲模型字段，按指定字段和方式排序結果集。

例：_order = "create_date desc"：根據建立時間降序排列。可指定多個字段。
不指定desc默認升序排列；不指定_order默認id升序排列。

_constraints：自定義約束條件。模型建立/編輯數據時觸發，約束未經過彈出錯誤提示，拒絕建立/編輯。

格式：_constraints = [(method, 'error message', [field1, ...]), ...]
method：檢查方法。返回True|False
error message：不符合檢查條件時（method返回False）彈出的錯誤信息
[field1, ...]：字段名列表，這些字段的值會出如今error message中。

_sql_constraints：數據庫約束。

例：_sql_constraints = [ ('number_uniq', 'unique(number, code)', 'error message') ]
會在數據庫添加約束：
CONSTRAINT number_uniq UNIQUE(number, code)

_inherit：單一繼承。值爲所繼承父類_name標識。如子類不定義_name屬性，則在父類中增長該子類下的字段或方法，不建立新對象；如子類定義_name屬性，則建立新對象，新對象擁有父類全部的字段或方法，父類不受影響。

格式：_inherit = '父類 _name'

_inherits：多重繼承。子類經過關聯字段與父類關聯，子類不擁有父類的字段或方法，可是能夠直接操做父類的字段或方法。

格式：_inherits = {'父類 _name': '關聯字段'}

3.字段屬性

基礎類型

Char：字符型，使用size參數定義字符串長度。
Text：文本型，無長度限制。
Boolean：布爾型（True，False）
Interger：整型
Float：浮點型，使用digits參數定義整數部分和小數部分位數。如digits=(10,6)
Datetime：日期時間型
Date：日期型
Binary：二進制型
selection：下拉框字段。

例：state = fields.Selection([('draft', 'Draft'),('confirm', 'Confirmed'),('cancel', 'Cancelled')], string='Status')

Html：可設置字體格式、樣式，可添加圖片、連接等內容。效果以下：
 

截於odoo自帶項目管理模塊

關係類型

One2many：一對多關係。

定義：otm = fields.One2many("關聯對象 _name", "關聯字段",string="字段顯示名",...)
例：analytic_line_ids = fields.One2many('account.analytic.line', 'move_id', string='Analytic lines')"

Many2one

定義：mto = fields.Many2one("關聯對象 _name", string="字段顯示名",...)
可選參數：ondelete，可選值爲‘cascade’和‘null’，缺省爲null。表示one端刪除時many端是否級聯刪除。

Many2many

定義：mtm = fields.Many2many("關聯對象 _name", "關聯表/中間表","關聯字段1","關聯字段2",string="字段顯示名",...)
其中，關聯字段、關聯表/中間表可不填，中間表缺省爲：表1_表2_rel
例：partner_id= fields.Many2many("res.partner", string="字段顯示名",...)"

複雜類型

參數

readonly：是否只讀，缺省值False。
required：是否必填，缺省值Falsse。
string：字段顯示名，任意字符串。
default：字段默認值
domain：域條件，缺省值[]。在關係型字段中，domain用於過濾關聯表中數據。
help：字段描述，鼠標滑過期提示。
store：是否存儲於數據庫。結合compute和related使用。

例：sale_order = fields.One2many("sale.order", "contract_id",string="銷售訂單", domain=[('state','=','sale')])

compute：字段值由函數計算，該字段可不儲存於數據庫。

例：amount = fields.Float(string="金額總計", compute=‘_compute_amount’,store=True)
_compute_amount爲計算函數。

related：字段值引用關聯表中某字段。

如下代碼表示：company_id引用hr.payroll.advice中company_id

advice_id = fields.Many2one('hr.payroll.advice', string='Bank Advice')
company_id = fields.Many2one('res.company', related='advice_id.company_id',
string='Company', store=True)

4.最後

以上便是Model的主要屬性，下一節會介紹Model中經常使用的方法