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|Falseerror 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中常用的方法