解决办法：

1
2

sudo apt-get install ttf-wqy-zenhei
sudo apt-get install ttf-wqy-microhei

原本以为只要apt-get直接安装就可以了，可是没想到出现了下面的报错提示：

1

The switch --header-spacing, is not support using unpatched qt, and will be ignored.The switch --header-html, is not support using unpatched qt, and will be ignored.The switch --footer-html, is not support using unpatched qt, and will be ignored.QStandardPaths: XDG_RUNTIME_DIR not set, defaulting to '/tmp/runtime-odoo'\nqt.qpa.screen: QXcbConnection: Could not connect to display \nCould not connect to any X display.\n

看来这个插件不能直接安装，解决方案如下：

1
2
3
4
5
6
7
8

# Uncomment the next line if you have installed wkhtmltopdf
# sudo apt remove wkhtmltopdf
cd ~
# Select an appropriate link for your system (32 or 64 bit) from the page https://wkhtmltopdf.org/downloads.html and past to the next line
wget https://github.com/wkhtmltopdf/wkhtmltopdf/releases/download/0.12.4/wkhtmltox-0.12.4_linux-generic-amd64.tar.xz
tar xvf wkhtmltox*.tar.xz
sudo mv wkhtmltox/bin/wkhtmlto* /usr/bin
sudo apt-get install -y openssl build-essential libssl-dev libxrender-dev git-core libx11-dev libxext-dev libfontconfig1-dev libfreetype6-dev fontconfig

某天公司的官网打不开了，报错提示是Mysql服务器不让连接，运营的同事找到技术，让帮忙看一下问题。由于这个官网是祖传项目，且并不归我们组负责，等要来服务器的管理权限，根据当时的问题表现，以为是某种原因导致的mysql不让远程访问，想着把权限开了不就得了。然而，等我登录上mysql以后才发现，数据库没了…

原因排查

数据库没了可还行，第一反应是服务器被人黑了，查看history看到一堆命令代码，其分析其中的代码发现，这个登陆者先备份了数据库，然后scp到了另外一台服务器上。看到这，心想实锤了，肯定是被黑了（当时
心里还在想这个黑客这么不专业，居然不清理痕迹，后来才知道可能是我误会了）。既然被黑了，那想想怎么恢复数据吧，开始去找mysql的binlog。 在寻找mysql binlog的过程中，突然发现/var/lib/mysql文件夹下怎么还有一个数据库，根据mysql的进程，我一直以为msyql的数据库文件夹位于/www/server/data下，然后看了一下这个库的大小，5.6G，感觉像是真正的数据库。

奇怪的是不知道为什么mysql的启动并没有加载这个文件夹里的数据，后来查看/etc/my.cnf和服务的启动脚本，均指向/var/www/data文件夹。这是我一直很纳闷的一点，不知道当初的技术是怎么启动的mysql。

又出幺蛾子

因为不知道mysql的正确启动方式，只能尝试把数据库的datadir指向/var/lib/mysql，然后重启mysql服务。重启之后，可以使用原来的密码进行登录了，这进一步证实了这个才是原来真正的数据库文件。进入数据库之后，show tables发现所有的表都在，尝试查询其中某个表，出了新的问题：

1

ERROR 1146 (42S02): Table 'database.tablename' doesn't exist

这个表明明存在，可是却不能查询，在google了一阵之后得知，我们的mysql使用的innodb引擎，出现这个提示一般就是缺少ib*文件导致的（ibdata1、ib_logfile0和ib_logfile1）。但是奇怪得是，我的mysql文件夹下明明都存在这几个文件，莫非是文件坏了？

解决方案

又经过一番的探索，终于在my.cnf文件中找到了这么一行：

1

innodb_data_home_dir = /www/server/data

看来应该是innodb设置的问题，把配置改成/var/lib/mysql

重启mysql，正常！

对于熟练开发odoo第三方模块的人员来说，继承重载是很自然很顺滑的操作，我们所写的大部分模块都是在现有模块的基础上的修修补补。那么，现在有一个问题，假如我想修改基类的某个方法，那么该如何做呢？

基类重载不同于三方模块的继承

首先明确，这里的基类的概念，指的是Model\AbstractModel和BaseModel。这些类跟我们平时继承的对象不同的地方在于，基类没有实例化，也就是没有_name属性，不能通过_inherit属性来继承。所以，我们要想修改BaseModel中的一些内置方法，就得另辟蹊径。当然，修改源码是最简便的途径，但是，还是那句话，这样会污染了源码，一旦有了问题，会影响问题的排查速度。

那么究竟应该如何修改基类的内置方法呢？

我们知道python的继承，后定义的方法会覆盖掉前面定义过的方法，我们可以根据这个原理来修改内置类的方法。

举例来说，我们常用的name_search方法定义在BaseModel中，name_search原本接收的参数数量是4个：

1
2
3
4

# models.py>BaseModel
@api.model
def name_search(self, name='', args=None, operator='ilike', limit=100):
    ...

现在我们希望给name_search添加一个参数而不改动models.py的源码，那么我们可以新定义一个模块，然后在models.py中这么写：

1
2
3
4
5
6
7
8
9
10
11
12

from odoo import models

...

@api.model
def name_search(self, name='', args=None, operator='ilike', limit=100, options=None):
    # override name search in base model.
    # add fields in options, to search more fields.
    return _name_search(self, name, args, operator, limit=limit, name_get_uid=None, options=options)


models.Model.name_search = name_search

通过对name_search方法的重定义，我们就可以给name_search方法新添加了一个带默认值的参数，带默认值的原因是为了防止因为多加参数而导致的其他模块通过正常方式重写name_search方法而引发异常。

由此，我们可以看出，这种方式的重载的优先级是高于正常的重载的，这也与我们的思维一致。

需要注意的一点是，name_search方法的第一个参数是self，如果name_search方法中的内部方法也被重载了，那么是不能通过self.xxx的方式进行调用的，因为那样调用的是还是原有的方法，对于这种重载，我们需要显式的把self参数传入，就像上面代码中的_name_search方法一样。

问题

odoo中的x2many字段，在编辑状态下可以添加删除行，如果想要禁止编辑状态下的添加和删除，在原生状态下是不可以完成的，通常的思路是把x2many字段声明为只读:

1
2
3

<div>
    <field name="lots_info" editable="bottom" readonly="1"/>
</div>

lots_info是个one2many类型的字段，其值是通过计算赋值的，但这样做存在下面几个问题：

• 虽然lots_info的tree视图只读了，但是单击某一行依旧有弹窗弹出，而且带有保存并关闭、保存并新建等按钮。
• 只读字段不能缓存，单击保存并关闭后，再次打开该列，并没有上次的信息。
• 只读字段不会保存到数据库中。

解决办法

问题出现了，那么我就需要找到适当的解决办法来解决这个问题，毕竟，这个需求的场景是存在并且有一定的合理性。

目前我们知道，对于添加了readonly属性的字段并不会被存储到数据库当中，即便store=True。这个过程不是在后端代码中进行的，而是在前端js触发保存的那一刻就舍弃了带有readonly的字段。因此，我们需要找到一种途径来确保即便字段声明了readonly也能够被存储起来。第二个问题，对于单击弹窗的问题，我们需要阻断这个弹窗的操作，让它在我们需要的条件下不进行弹窗。

经过长时间的探索，没有发现一种好的方法能够让odoo保存带有readonly属性的字段，退而求其次的，我在context中添加了一个属性x2m_readonly，只要发现字段的context中包含这个属性，就禁用掉前端的create和delete action。至于编辑，阻止掉弹窗就自然而然不能编辑了。

这段逻辑的开发完全基于js，不涉及掉后端python代码。这里简要介绍一下基本思路和关键代码。

首先要明确，我们常见的One2many是odoo qweb框架的一个部件(widget)，被定义为One2manyField，One2manyField和Many2manyField同是X2manyField的子类。这些都定义在RelatedField部件中。One2many部件根据当前的编辑模式（编辑、只读）会有两种不同的模式：edit和readonly，对应于我们是否打开编辑按钮的操作。

在readonly模式下

我们单击One2many部件中某一行的动作会打开一个叫做FormViewDialog的部件，这个部件继承自ViewDialog。

FormViewDialog有一个动作叫open，这个就是我们单击x2many部件某一行弹窗的动作，因此，我们要重载这个方法：

1
2
3
4
5
6
7
8
9

FormViewDialog.include({
        open: function () {
            // 添加x2m_readonly属性不弹窗
            if (!this.context.x2m_readonly) {
                // 没有设置x2m_readonly属性
                this._super();
            }
        },
    });

检测这个部件的context中是否包含x2m_readonly属性，不包含的我们才继续调用父类方法，完成弹窗的动作，否则直接忽略掉该动作，表现为”只读”。

在edit模式下

同样的，对于One2many编辑模式下的单击，它会触发One2many部件的私有方法_onEditLine，我们也要予以阻断：

1
2
3
4
5
6
7
8
9
10

One2manyField.include({

       _onEditLine:function(ev){
           // x2m_readonly 不予响应编辑事件
           if(!this.field.context.x2m_readonly){
               this._super(ev)
           }
       },

       ...

接下来要处理的是编辑模式下的Add new line和delete按钮，这个需要在部件显示的时候将其”击毙”，部件显示的方法为_render:

1
2
3
4
5
6
7
8

_render: function () {
        ...
        // 对于拥有x2m_readonly属性的字段，不显示添加和删除按钮
        if (this.field.context.x2m_readonly){
            this.activeActions.create = false;
            this.activeActions.delete = false;
        }
        ...

这样就基本解决了我们开始所碰见的问题。

最后，需要源代码的同志戳这里

有个下拉列表，是通过数据库取的值，但是提交的时候validate_on_submit一直返回的是False

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

class PushForm(FlaskForm):
    
    shops = SelectField("店铺", choices=[])
    submit = SubmitField("推单")

form = PushForm()
shops = Shop.query.all()
shop_dict = [(s.id, s.name) for s in shops]
form.shops.choices += shop_dict

if request.method == "GET":
    return render_template("push/get.html", form=form)

if request.method == "POST":
    # 推单
    if form.validate_on_submit():
        pass
    return render_template("push/get.html", form=form)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

<form method="post" enctype="multipart/form-data">
    {{form.hidden_tag()}}
    <div class="box-header with-border">
        {% include 'message.html' %}
        {% if form.errors %}
        {{ form.errors }}
        {% endif %}
    </div>

    <div class="box-body">
        <div class="form-group">
            <label>请选择一个店铺</label>
            {{form.shops(class_="form-control select2",placeholder="请选择一个要推单的店铺")}}
        </div>
    </div>

    <div class="box-footer">
        <div class="col-md-12">
            {{form.submit(class_="btn btn-primary pull-right")}}
        </div>
    </div>

</form>

按照网上的排错顺序：

• Form表单中已经加入了csrf_token
• form对象的choices也已经设置

在页面上打印出错误日志，显示：

1

['Not a valid choice']}

后来查到，原因可能是我的choice第一个参数是int类型，而SelectedField默认会把int转换成str,所以才会显示无效的选项。

解决方案就是在SelectedField中加入关键字coerce

1

coerce=int

重载的概念

开发的过程中，我们很有可能会碰到这样的场景，需要修改官方定义的某个模块中的某个方法。虽然我们可以直接修改源码达到目的，但那样会污染官方源码，不方便于维护和移植。

重载的概念就是通过继承，重写原有模块的某些方法，拦截原有的执行路径，达到修改或是改造的目的。

简单的重载

接下来，我们先看一下，如何对一个既有模块的方法进行重载的操作，还是以我们的book_store模块为例，我们先给book_store.book对象添加要给新的类方法：log_book_name

1
2
3

@api.one
def log_book_name(self):
    _logger.info(f"图书名称：{self.name}")

非常简单，就是打印一下本书的名字，然后为了方便测试，我们在使用odoorpc远程调用一下这个方法：

1
2
3
4
5
6
7
8
9

odoo = odoorpc.ODOO(host=host, port=port)
odoo.login(db, user, password)

# 调用log_book_name方法

book_obj = odoo.env['book_store.book']
book = book_obj.browse(1)

book.log_book_name()

运行测试，可以看到，当我们修改book的内容时，后台日志会输出本图书的名字。

重载

现在，我们希望能够把作者的名字也添加到日志中，但是不修改Book类的代码。这时候我们需要新建一个类，继承自Book(这里为了好区别，新建要给代码文件，名为SubModel.py):

1
2
3
4
5
6
7
8

class SubBook(models.Model):

    _inherit = "book_store.book"

    @api.one
    def log_book_name(self):
        """重载父类方法"""
        _logger.info(f"图书名称{self.name},作者：{self.author.name}")

重启升级模块儿后，通过rpc调用log_book_name方法可以看到，输出的日志已经带有作者信息了：

复用父类调用的结果

如果希望在父类方法返回的结果上进行修改，可以通过super方法进行调用，这个例子中由于父类方法并不返回值，因此只是调用了一下父类，并没有真正的复用：

1
2
3
4
5

@api.one
def log_book_name(self):
    """重载父类方法"""
    res = super(SubBook,self).log_book_name()
    _logger.info(f"图书名称{self.name},作者：{self.author.name}")

可以看到，父类方法也被调用：

私有方法不会被重载

有个例外，就是如果你的方法是私有方法(双下划线开头)，那么重载将不会起作用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Book(models.Model):
    ...
    @api.one
    def log_book_name(self):
        self.__log_book_name()

    def __log_book_name(self):
        print('Book私有方法')
        _logger.info(f"图书名称：{self.name}")

class SubBook(models.Model):
    ...
    def __log_book_name(self):
        print('SubBook私有方法')
        _logger.info(f"图书名称{self.name},作者：{self.author.name}")

将只有Book的方法会被调用，这点跟Python本身的继承表现是一致的。

多层重载

细心的朋友可能会有疑惑，如果多个子类都重载了父类的方法，那么会执行哪一个呢？下面我们就来揭晓这个问题的答案。

上面我们创建的一个子类SubBook，这里我们再次创建一个子类SubBook2，方法跟SubBook类似：

1
2
3
4
5
6
7
8
9
10

class SubBook2(models.Model):

    _inherit = "book_store.book"

    @api.one
    def log_book_name(self):
        """重载父类方法"""
        # res = super(SubBook,self).log_book_name()
        _logger.info(f"SubBook2的方法：图书名称{self.name},作者：{self.author.name}")

运行rpc脚本，输出结果如下：

由此可以看出，当有多个子类重载了同一个父类方法时，只有最后加载的那个子模块的方法会被调用。

指定重载

如果，在子类SubBook中调用了父类的方法，同时子类SubBoo2也调用父类方法，那么会出现什么结果呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

class SubBook(models.Model):

    _inherit = "book_store.book"

    @api.one
    def log_book_name(self):
        """重载父类方法"""
        # res = super(SubBook,self).log_book_name()
        _logger.info(f"SubBook的方法：图书名称{self.name},作者：{self.author.name}")
        super(SubBook,self).log_book_name()

class SubBook2(models.Model):

    _inherit = "book_store.book"

    @api.one
    def log_book_name(self):
        """重载父类方法"""
        # res = super(SubBook,self).log_book_name()
        _logger.info(f"SubBook2的方法：图书名称{self.name},作者：{self.author.name}")
        super(SubBook2,self).log_book_name()

输出：

可以看到，三个方法都被调用了。因此，在子类中使用Super调用父类方法，会调用继承链上所有的重载方法。

那么，我们如何只通过子类SubBook2调用父类方法，而不触发SubBook中的同名方法呢?

答案是SubBook2中直接条用SubBook的父类方法：

1

super(SubBook,self).log_book_name()

细心的朋友一定注意到了，odoo中的方法经常会看到由api装饰的方法，这是Odoo从8.0起引入的新的编程API，那么为什么要引入新API呢，这要从更早的历史说起。

7.0之前的API

当年那是Odoo还叫OpenERP的时代，OpenObject对象的方法通常都需要带着几个固定的参数：cr,uid,ids,context等等，写起来很繁琐，比如下面的例子：

1
2

def btn_import(self,cr,uid,ids,context=None):
    ...

到了8.0，可能Odoo官方的开发人员也觉得这样写起来太繁琐了，于是乎，他们引入了新API，封装在api.py文件中，主要有一下几种类型：

• model
• multi
• one
• constrains
• depends
• onchange
• returns

下面我们就这几种类型进行详细的介绍。

one

作用： 表示被封装的方法接受单一的对象，用于处理一些单个对象的方法。
返回值： [None](部分不负责的教程里说不返回值)
v7版本写法： def funct(self,cr,uid,ids,context)

举例：
视图文件中添加一个按钮，对应的触发方法：

1
2
3

@api.one
def button_test(self):
    self.name = "xxx"

multi

作用：表示被封装的方法接收一个集合对象，正好与one对应。
返回值： 被封装方法的返回值
v7版本写法： model.method(cr, uid, ids, args, context=context)

multi典型的用法即odoo对象的write方法：

1
2
3
4

@api.multi
def write(self, vals):
    res = super(Book, self).write(vals)
    return res

这里的self是一个集合对象，vals是待更新的字段和值的字典，这里的例子我们没有用到self，只是调用了父类的write方法，将vals写入到数据库中。如果我们要修改某个值，需要对self进行迭代，然后更新字段的值。

model

作用：self代表一个记录集合，但内容与记录集无关，只是与model类型相关。
返回值： 被装饰方法的返回值
v7版本写法： model.method(cr, args)

典型应用是对象的create方法：

1
2
3

@api.model
def create(self,vals):
    return super(Book,self).create(vals)

self是个对象集合，但是creat方法内部却与self这个集合没有关系，只是用了self的model类型，将vals的值进行创建操作。

contrains

作用：给某个字段添加限制条件
v7版本：是通过_constrains属性关联验证方法的方式实现

到了新API，不需要添加_constrains属性了，直接给校验方法添加constrains装饰即可。

1
2
3
4
5
6

age = fields.Integer(string="age")  

＠api.constrains('age')
def _check_age(self):
    if self.age<16:
        raise ValueError(_('Age must be older than 16'))

这样就限制了age字段只能输入比16大的数据。

另外一种constrains

odoo支持另外一种添加限制的方式，即通过sql约束的方式。方法是在odoo类对象中添加_sql_constrains属性，值是一个包含了元组的列表，元组的三个值分别是约束名，约束条件和警告信息，看一个例子：

1
2
3
4
5
6
7
8

_sql_constraints = [
    ('name_description_check',
     'CHECK(name != description)',
     "The title of the course should not be the description"),
    ('name_unique',
     'UNIQUE(name)',
     "The course title must be unique"),
]

这样做的好处是，在数据库层面就限制了数据的校验，而不是在代码层面的校验，显然效率会更高。缺点是在添加限制之前，数据库中不能存在违反约束的数据，否则约束会添加失败。

depends

depends主要用于compute方法，v8当中已经取消了function字段，对于任何fields都可以通过添加compute属性动态赋值。depends就是用来标该方法依赖于哪些字段的装饰。

1
2
3

@api.depends('date')
def _get_book_age(self):
    self.age = (datetime.now().date() - self.date).days

对于compute方法来说，加不加depends装饰的区别在于，加了depends的方法会在依赖的字段发生改变时重新计算本字段的值，而不加depends的方法只在触发的第一次调用，也就是说不会持续更新。

returns

returns的用法主要是用来指定返回值的格式，它接受三个参数，第一个为返回值的model，第二个为向下兼容的method，第三个为向上兼容的method。

第一个参数如果是对象本身，则写’self’,如果是其他对象，则写其他对象名如：@api.returns(‘ir.ui.view’)。

例如：

1
2
3
4
5
6

@api.multi    @api.returns('mail.message', lambda value: value.id)
def message_post(self, **kwargs):
    if self.env.context.get('mark_so_as_sent'):
        self.filtered(lambda o: o.state == 'draft').with_context(tracking_disable=True).write({'state': 'sent'})
        self.env.user.company_id.set_onboarding_step_done('sale_onboarding_sample_quotation_state')
    return super(SaleOrder, self.with_context(mail_post_autofollow=True)).message_post(**kwargs)

returns主要用于确保新旧API返回值的一致，并不常用。

odoo支持继承，可以方便地像python语言中的继承拓展既有的对象属性，这篇第一部分将介绍Odoo中的继承，搜索也是Odoo中常见的操作之一，第二部分将介绍Odoo中的搜索逻辑。

继承

这里我们还是沿用前面的书店模块，之前我们有了图书这个模型，现在我们希望书店能够上架一种新的图书-电子书，电子书区别于纸质书的特点就是无需纸张，但是需要规定电子书的格式，比如常见的epub,mobi,awz3等等，因此，我们需要在前边的图书模型上进行拓展，又不能影响既有图书的属性，怎么办，这就需要用到了继承，我们可以新建一个电子图书的模型，继承自图书，新增电子书属性。

继承的方式

odoo的继承不是像python的继承直接在class的括号中添加继承类，而是在类属性_inherit中添加，如上面的例子，代码就可以写成下面的样子：

1
2
3
4
5

class eBook(models.Model):
    _inherit = "book_store.book"

    etype = fields.Selection(selection=[('mobi', 'Mobi'), ('epub', 'Epub'), (
        'awz', 'Awz3')], string='电子书格式', default='epub')

需要注意的是，上面的这种方式，在实际数据库中还是同一张表的扩展，也就是说，这种方式不能实现我们前面所说的效果。这种继承方式的使用场景是继承自odoo官方模块，为原有模块进行扩展而不修改源码，这样可以保持官方代码的干净，避免带来污染。如果想要使用另一张表，则需要给新模型起一个新的名字：

1
2
3
4
5
6

class eBook(models.Model):
    _inherit = "book_store.book"
    _name = "book_store.ebook"

    etype = fields.Selection(selection=[('mobi', 'Mobi'), ('epub', 'Epub'), (
        'awz', 'Awz3')], string='电子书格式', default='epub', help='')

这样的数据库中就会多出一张表，包含所有的book_store_book表中的字段，并且还有ebook对象新增的字段：

两种方式各有优缺点，请读者根据实际情况灵活运用。

多继承

Odoo也支持多继承，方法是把_inherit的值变成一个要继承的列表：

1
2
3
4
5
6

class sBook(models.Model):
    _inherit = ["book_store.book","book_store.ebook"]
    _name = "book_store.sbook"

    etype = fields.Selection(selection=[('mobi', 'Mobi'), ('epub', 'Epub'), (
        'awz', 'Awz3')], string='电子书格式', default='epub', help='')

继承的顺序从左到右

属性继承

Odoo还有另外的一种继承方式，不指明要继承的对象，而是指定本对象的某个Many2one的字段继承自一个其他对象，被继承的该对象的字段自动加载到本对象中，并且当其中任何一方的值发生变化时，都会同步到另一方中，这里把这种继承方式命名为属性继承。说的比较抽象，接下来我们举个栗子：

新建对象会员图书(sbook)，但是此对象不继承任何一个对象，只是在属性中添加一个对电子图书(ebook)的Many2one关联字段，并在_inherits属性中声明这个字段：

1
2
3
4
5
6
7

class sBook(models.Model):
    
    _name = "book_store.sbook"
    _inherits = {'book_store.ebook': 'ebook_id'}

    ebook_id = fields.Many2one(
        'book_store.ebook', string='ebook', ondelete='restrict', required=True, help='')

_inherits属性是个字典，key为Many2one字段中外关联的对象名，value为Many2one的字段名。然后我们为sBook对象编写一个视图：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

<record model="ir.ui.view" id="book_store.slist">
      <field name="name">会员图书列表</field>
      <field name="model">book_store.sbook</field>
      <field name="arch" type="xml">
        <tree>
          <field name="name"/>
          <field name="author"/>
          <field name="date"/>
          <field name="price"/>
        </tree>
      </field>
    </record>

    <record id="book_store.sbook_form" model="ir.ui.view">
      <field name="name">会员图书</field>
      <field name="model">book_store.sbook</field>
      <field name="arch" type="xml">
        <form string="图书详情" class="">
          <sheet>
            <h1>
              <field name="name" invisible="0"/>
            </h1>
            <group>
              <field name="ebook_id"/>
              <field name="author" invisible="0"/>
              <field name="date" invisible="0"/>
              <field name="price" invisible="0"/>
              <field name="ref" invisible="0"/>
            </group>
          </sheet>
        </form>
      </field>
    </record>

    <record model="ir.actions.act_window" id="book_store.saction_window">
      <field name="name">会员图书</field>
      <field name="res_model">book_store.sbook</field>
      <field name="view_mode">tree,form</field>
    </record>

然后升级模块，可以看到如下图：

好像没有什么特别之处。。。别急，我们来修改一下会员图书的名字，将其改为”流浪地球-最终版”，并把作者改回”刘慈欣”:

发现了没有，ebook属性的名字，随着我们会员图书的名字的改名而改名，并且ebook的作者字段也变成了我们所选的”刘慈欣”。

这就是Odoo中比较著名的模板继承方式，典型的应用就是官方模块中的产品模板和产品的关系，在Odoo原生模块中，有一个对象叫做product.template，顾名思义就是产品模板，指的是一系列产品的通用模板属性。而在销售、采购和仓储的实际运用中，使用的是叫product.product的对象，这个才是真正的产品。product.product和product.template的关系就是我们上面所说的属性继承的关系，product.pruduct中一个many2one的字段product_tmpl_id关联的就是product.template，当product.template中的属性发生变化时，没有被重写（注意，product.product对象中有些字段覆盖了product.template中的字段）的属性就会跟着变化，形成了一种有趣的引用关系。关于这点，读者可以到产品中修改一下属性进行体会。

搜索

Odoo中最常用的搜索就是位于Form页面右上角的搜索框了，搜索框的逻辑包括过滤、分组，基本的操作可以通过XML文件配置出来，有些比较高级的搜索需要通过代码的方式实现。

基本搜索

默认情况下，搜索框只有一个搜索对象的name字段的功能：

如果想要搜索其他字段，就需要在filter中自行选择要搜索的字段和需要的操作符，进行过滤搜索：

可供选择的操作符包括如下几种：

• 包含
• 不包含
• 等于
• 不等于
• 已设置
• 未设置

这样基本可以满足用户的需求。

这里可选字段包括了本对象中所有可存储的字段，也就是在数据库中可搜索的字段，对于compute类型的字段来说，不可以搜索，也就不会出现在备选字段中。

用户可以点击favorites进行收藏，将当前的筛选条件进行保存，以供下次搜索使用。

自定义搜索

基本搜索满足了用户的基本搜索需求，但是不够简洁快速，如果想要更快捷的方式，就需要自定义搜索条件了。自定义搜索条件，基本可以通过配置XML文件实现，下面就详细介绍一下这几种搜索方式。

Filter

顾名思义，Filter就是过滤，具体的定义规则就是在XML文件中定义一个search视图：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

<record id="book_store_search_view" model="ir.ui.view">
      <field name="name">图书搜索</field>
      <field name="model">book_store.book</field>
      <field name="arch" type="xml">
        <search string="图书搜索">
          <field name="author"/>
          <field name="date"/>
          <field name="price"/>
          <separator/>
          <filter name="liu_book" string="大刘小说" domain="[('author','=','刘慈欣')]" />
          <separator/>
          <group expand="0" string="Group By">
            <filter name="author" string="按作者分组" domain="[]" context="{'group_by':'author'}"/>
          </group>
        </search>
      </field>
    </record>

search结点中的三种标签：

• field: 按字段搜索，即你输入值以后，下拉进行筛选：
  

• filter: 按照预定的domain进行过滤：
  

• group: 根据字段进行分组：
  
  分组的做法是在context属性的中传入’group_by’的字段值。

计算字段的搜索

在Odoo中还有一类字段，是不存储在数据库中的，而是通过计算的方式在需要显示的时候计算出来的值。这类字段通常会使用compute属性，compute对应的是一个方法，这个方法在字段被显示和调用时调用。

沿用以前的模块，我们给book模型添加一个书龄的属性，该属性是由计算出来的：

1
2
3
4
5

age = fields.Integer('书龄', compute="_get_book_age", search="_search_ages")

@api.depends('date')
def _get_book_age(self):
    self.age = (datetime.now().date() - self.date).days

在form页面中会显示出该书的书龄：

你在filter工具中是看不到该字段的，那么我们如何对书龄进行搜索呢？

这里需要用到我们前面说过的一个字段的一个属性，search，search是用来重载字段被搜索时的方法的。搜索书龄，我们可以这么写：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

@api.model
def _search_ages(self, operator, operand):
    """search方法"""
    if operator not in ('>', '>=', '<', '<=', '='):
        return []
    if type(operand) not in (float, int):
        return []
    start_date = datetime.now().date() - timedelta(days=operand)
    ops = {
        ">": "<",
        ">=": "<=",
        "<": ">",
        "<=": ">=",
        "=": "="
    }
    return [('date', ops[operator], start_date)]

search方法接收两个参数，一个操作符，一个是操作数，操作符根据字段的类型不同而不同，我们这里是integer类型，所对应的操作符就是大于小于和等于等操作符。search方法的返回值是一个domain对象，也就是有元组组成的列表。odoo会根据domain对记录进行过滤，并显示结果，最后的效果图如下：

。

前面一篇文章，我们介绍了如何从无到有地创建一个模块，本篇将介绍Odoo中常见得几种字段类型和基本的视图类型。

字段类型

由于Odoo使用了自己编写的ORM框架，因此它有着自己的一套与数据库映射的关系逻辑，简单地说就是由简单字段关系和复杂字段关系组成的。简单的字段关系比如Char,Integer,Float等，复杂字段关系如Many2one，Many2many等。下面就常见的几种字段类型进行简要的介绍。

通用字段属性

有些属性是字段共同拥有的，如下表：

Char

字符类型，对应数据库中varchar类型，除了通用类型外接收另外两个参数：

• size: 字符长度，超出的长度将被截断
• trim: 默认True，是否字段值应该被去空白。

Text

文本类型，对应数据库中的text类型，不限长度，没有额外的参数。

Html

Html类型，用于存储一段HTML代码，对应数据库中的text类型，接收下面几个参数：

• sanitize：是否过滤安全字符(默认True)
• sanitize_tags： 是否过滤的html标签（只接收白名单列表标签，默认True）
• sanitize_attributes： 是否过滤的html属性（只接收白名单列表属性，默认True）
• sanitize_style： 是否过滤style属性(默认False)
• strip_style： 是否去除style属性中的空白(默认False)
• strip_classes:是否去除class属性中的空白（默认False)

Date

日期类型，对应于数据库中的date类型，该字段包括如下几个特有属性：

• today: 当前日期
• context_today： 返回客户端时区的当前时间
• to_date: 将时间值转换为date类型的时间
• to_string: 将时间值转为文本

Datetime

时间类型，对应于数据库中的timestamp类型，该字段包括如下几个特有属性：

• now: 当前时间
• today: 当前日期
• context_timestamp： 客户端时区的当前时间戳
• to_datetime：将时间值转换成datetime类型
• to_string： 将时间值转成文本

Binary

二进制文件类型，接收三个参数：

• prefetch: 默认False
• context_dependent：默认True
• attachment：默认False，是否作为附件存储

二进制文件作为附件存储时存在服务器指定的文件夹路径中，否则存在数据库中，对应的数据库类型为bytea.

Selection

下拉选择类型，多选一类型，不同于Many2one类型，Selection类型在数据库中对应的类型是int4或varchar类型。

除了通用的属性，另外接收2个参数：

• selection： 可选的范围值，值和名称组成的元组列表。
• validate: 默认True，是否写入时校验。

Selection包含如下的属性或方法：

• get_values: 返回可选的值列表。

Reference

引用类型(继承自Selection)，对应数据库类型varchar，Reference字段不同于Many2*类型的地方在于Many2*类型的字段的comodel是固定的，而Reference可以提供一种动态的选择。

比如，我们给模型book添加了一个ref字段，类型为Reference，关联两种类型，一个出版商，一个作者，那么ref字段就可以供用户在使用的时候自行选择绑定的记录：

Many2one

多对一类型，对应于数据库中的类型是int4，相当于数据库主表中的外键。可选的参数如下：

• comodel_name： 被关联的对象
• domain： 过滤条件
• context： 上下文
• ondelete： 删除时的选项，可选set null(本字段设置null)，restrict(严格控制，只有先删除本字段才允许删除)和cascade(级联删除本字段关联的所有记录)。
• auto_join： 当字段被搜索时是否自动聚合，默认为False
• delegate: 当设置为True时，关联对象的所有字段将在本字段变得可用。

One2many

一对多类型，返回值是一个关联对象的集合。接收的参数列表如下：

• comodel_name： 关联对象名称
• inverse_name： 在Many2one对象中的字段名 默认为None
• domain： 过滤条件
• context： 上下文
• auto_join： 当字段被搜索时是否自动聚合，默认为False
• limit： 读取的条数限制
• copy: 是否允许拷贝（默认False)

定义一个One2many对象时，要在关联的对象中定义一个Many2one的字段类反过来关联本对象。比如，一个出版商签约了多个作者，那么出版商和作者就是一对多的关系（当然也可以定义为多对多的关系），用代码表示出来就是下面这个样子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

class Author(models.Model):

    _name = 'book_store.author'

    name = fields.Char('名称', help='作者名称')
    age = fields.Integer('年龄')
    publisher_id = fields.Many2one(
        'book_store.publisher', string='签约出版商', ondelete='no action', required=True, help='')


class Publisher(models.Model):

    _name = "book_store.publisher"

    name = fields.Char('名称', help='出版商名称')
    signed_authors = fields.One2many(
        'book_store.author', 'publisher_id', string="签约作者")

对于One2many和Many2many对象，有几种特殊的操作，就是在关联对象中创建或是修改本对象时的操作：

• (0,0,{values}) 根据values里面的信息新建一个记录。
• (1,ID,{values})更新id=ID的记录（写入values里面的数据）
• (2,ID) 删除id=ID的数据（调用unlink方法，删除数据以及整个主从数据链接关系）
• (3,ID) 切断主从数据的链接关系但是不删除这个数据
• (4,ID) 为id=ID的数据添加主从链接关系。
• (5) 删除所有的从数据的链接关系就是向所有的从数据调用(3,ID)
• (6,0,[IDs]) 用IDs里面的记录替换原来的记录（就是先执行(5)再执行循环IDs执行(4,ID）

举例来说，就是我希望在按钮的触发事件中同时创建一个出版商和多个作者，而不是一步一步地创建，就可以这么写：

1
2
3
4
5
6
7
8

@api.one
def btn_test(self):
    """测试方法"""
    _logger.info(f"测试创建出版商和作者")
    self.env['book_store.publisher'].sudo().create({
        "name": "超新星出版社",
        "signed_authors": [(0, 0, {'name': '本杰明 巴顿', 'age': 90}),(0,0, {'name': '刘天然', 'age': 28})]
    })

Many2many

多对多类型，参数列表如下：

• comodel_name：关联对象名
• relation：关系表名
• column1：本对象的关联字段名
• column2：关联对象的关联字段名
• domain： 过滤条件
• context： 上下文
• limit: 读取条数限制

与One2many类似，但不同的是参数中多了一个relation，用来存储多对多关系的表名，需要注意的是，relation，column1和column2可以不提供，odoo会根据model名称自动生成，但是需要保证column1和column2是不同的值。

Id

integer类型，对应数据库中的int4，一般不需要定义。

视图类型

上面讲述了字段的列表，接下来我们看一下常见的视图类型。

最常见的视图有如下几种：

• form视图
• tree视图
• kanban视图
• graph视图
• gatt视图
  …

因为视图是前端展示用的，所以视图的种类多种多样，odoo也可以支持自定义视图，这就给了开发人员很大的灵活拓展性。每种视图的结构不一样，这里只介绍最常见的form和tree视图。

form 视图

一般的视图都是在record节点中，由arch结点包裹：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

<record id="book_store.book_form" model="ir.ui.view">
      <field name="name">图书</field>
      <field name="model">book_store.book</field>
      <field name="arch" type="xml">
        <form string="图书详情" class="">
          <header>
            <button type="object" name="btn_test" string="测试按钮"/>
          </header>
          <sheet>
            <h1>
              <field name="name" invisible="0"/>
            </h1>
            <group>
              <field name="author" invisible="0"/>
              <field name="date" invisible="0"/>
              <field name="price" invisible="0"/>
              <field name="ref" invisible="0"/>
            </group>
          </sheet>
        </form>
      </field>
    </record>

form视图就包括，header、sheet等部分，然后group节点可以对field进行分组，字段field的属性用来控制field的显示。

tree视图

把form视图代码中的form替换成tree就成了我们的列表视图，这里称之为列表视图是因为tree视图并不是真正的”树视图”,真正的树视图是可以展开的。

1
2
3
4
5
6
7
8
9
10
11
12

<record model="ir.ui.view" id="book_store.list">
      <field name="name">图书列表</field>
      <field name="model">book_store.book</field>
      <field name="arch" type="xml">
        <tree>
          <field name="name"/>
          <field name="author"/>
          <field name="date"/>
          <field name="price"/>
        </tree>
      </field>
    </record>

tree视图相对比较简单，一般就是对本对象要显示的属性的罗列，外加一些权限显示的控制。

其他类型的视图，读者可以在官方自带的模块中找到例子，这里就不列举了。

Odoo的视图层是个复杂的系统，其中的关于视图的定义，展示逻辑等都相对比较复杂，等有机会再另起一篇进行讨论。

本教程示例代码