发表于 | 分类于

话说，天下苦odoo的联系人地址久矣，不符合国情的情况下，输入还比较费劲。今天给大家带来一个快捷录入地址的模块——百度NLP模块

注册

既然要使用百度的服务，那么首先就得去他的百度云上注册账号。

注册完成后，去创建一个自然语言处理应用，并记录下应用的APPID、KEY和SECRET:

设置

然后，下载安装我们的百度NLP模块以后，在设置-百度NLP中填入你的应用ID,KEY和密钥：

在联系人中使用智能地址解析

然后我们就可以在联系人那里，方便地录入我们地联系人地址了，这里我们使用地址”北京市亦庄京东总部A座 刘强东 18611112222”作为示例：

对于联系人下面的子联系人类型，发票地址等也同样有效。

发表于 | 分类于

不知道你们是否碰到过这样的问题，在树形列表视图上想要显示x2many字段中某些字段的值。默认情况下，x2many如果显示在列表视图上，会显示为”x条记录”这个鬼样子，没有有效的信息。虽然，我们可以使用many2many_tags部件将其显示出来，但只能显示一个字段。

今天我们带来一个优雅一点的解决方案，list_preview_widget模块。这个模块内置了一个兼容char字段的小部件list_preview，我们只需要将要预览的部件使用这个小部件就可以预览明细里的字段了。

首先，我们安装好这个模块，然后在要添加预览的对象中新增一个文本字段，这里我们以stock.picking模块为例：

1
2
3
4
5
6
def _get_dispay_text(self):
        for picking in self:
            picking.display_text = ";".join(
                f"型号:{line.product_variant or '无'},数量:{line.product_uom_qty},备注:{line.sale_note or''}" for line in picking.move_ids_without_package)

display_text = fields.Char("明细预览", compute="_get_dispay_text")

我们新增加了一个文本字段display_text，这个字段的值是计算方式获取的，以方便我们灵活定制要显示的内容。

然后，我们在视图中新增这个字段，并标记为list_preview部件：

1
2
3
4
5
6
7
8
9
10
<record id="view_picking_list" model="ir.ui.view">
    <field name="name">view picking list</field>
    <field name="model">stock.picking</field>
    <field name="inherit_id" ref="stock.vpicktree"/>
    <field name="arch" type="xml">
    <field name="partner_id" position="after">
        <field name="display_text" widget="list_preview"/>
    </field>
    </field>
</record>

然后我们更新我们的自定义模块，可以看到分拣列表中已经有一个小图标，点击可以看到预览的内容：

有需要的同学欢迎到我的淘宝选购

发表于 | 分类于

odoo14 在 Ubuntu 18.04上安装并没有那么丝滑，首先碰到的错误就是:

1
2
3
4
5
6
The following information may help to resolve the situation:

The following packages have unmet dependencies:
 odoo : PreDepends: init-system-helpers (>= 1.54~) but 1.51 is to be installed
        Depends: python3-xlwt but it is not installable
E: Unable to correct problems, you have held broken packages.

意思就是找不到这个两个依赖包，既然系统中没有，那么我们手动来安装好了

init-system-helpers

我们使用wget命令获取init-system-helpers。

然后使用如下命令进行安装:

1
dpkg -i init-system-helpers_1.58_all.deb

python3-xlwt

同样的，我们使用wget下载python3-xlwt

然后使用命令安装:

1
dpkg -i python3-xlwt_1.3.0-3_all.deb

解决了这个两个依赖，再次安装odoo14就可以了。

发表于 | 分类于

适用环境 Ubuntu

odoo系统添加了HTTPS证书以后，打印出来的报表，缺失了css样式，后台可以查到的输出信息有：

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
40
QSslSocket: cannot resolve CRYPTO_set_id_callback
QSslSocket: cannot resolve CRYPTO_set_locking_callback
QSslSocket: cannot resolve sk_free
QSslSocket: cannot resolve sk_num
QSslSocket: cannot resolve sk_pop_free
QSslSocket: cannot resolve sk_value
QSslSocket: cannot resolve SSL_library_init
QSslSocket: cannot resolve SSL_load_error_strings
QSslSocket: cannot resolve SSLv3_client_method
QSslSocket: cannot resolve SSLv23_client_method
QSslSocket: cannot resolve SSLv3_server_method
QSslSocket: cannot resolve SSLv23_server_method
QSslSocket: cannot resolve X509_STORE_CTX_get_chain
QSslSockeQSslSocket: cannot resolve CRYPTO_num_lockst: cannot resolve OPENSSL_add_all_algorithms_noconf
QSslSocket: cannot resolve OPENSSL_add_all_algorithms_conf
QSslSocket: cannot resolve SSLeay
QSslSocket: cannot call unresolved function CRYPTO_num_locks
QSslSocket: cannot call unresolved function CRYPTO_set_id_callback
QSslSocket: cannot call unresolved function CRYPTO_set_locking_callback
QSslSocket: cannot call unresolved function SSL_library_init
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function sk_num
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function SSL_library_init
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function SSL_library_init
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function SSL_library_init
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function SSL_library_init
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function SSL_library_init
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function SSL_library_init
QSslSocket: cannot call unresolved function SSLv23_client_method
QSslSocket: cannot call unresolved function SSL_library_init
Exit with code 1 due to network error: UnknownNetworkError
QSslSocket: cannot call unresolved function CRYPTO_num_locks
QSslSocket: cannot call unresolved function CRYPTO_set_id_callback
QSslSocket: cannot call unresolved function CRYPTO_set_locking_callback

貌似是wkhtmltopdf缺少了某种解析的功能，通过google查到相关问题

找到解决方案(Ubuntu 18.04)：

1
apt-get install libssl1.0-dev

发表于 | 分类于

企业版的本质

首先，我们需要知道的一点，企业版不是一个完全独立的版本，而是在社区版的基础上附加了一个包含若干模块的addons包组成的企业版。也就是说，任何一个版本的社区版，只要配置好企业版的代码包，就成为了企业版。

企业版具体包含了哪些模块，读者可以到社区版的模块列表中查看哪些需要升级的模块即可，也可以到官方服务器上进行实际版本的体验。

安装

这里我们假设读者已经安装好了社区版，结合前面讲的，安装企业版就变成了一件非常容易的事情。

  1. 首先，我们将企业版代码包解压到任意目录中，例如，我们这里解压到了/opt/enterprise-14.0目录中。

  2. 然后我们编辑配置文件 /etc/odoo/odoo.conf 中的addons_path参数，将企业版的目录填进去：

    1
    addons_path = /opt/odoo14/addons,/opt/enterprise-14.0

  3. 重启odoo服务

这样就完成了企业版的升级。

升级数据库

企业版安装完成以后创建的数据库都是企业版的数据库，那么如何将原来是社区版的数据库升级到企业版呢？

方法也是非常简单：

到应用-模块 中搜索web模块，然后点击升级，等待此模块升级完成以后，你的数据库就会变成企业版啦。

mixoo ❤ odoo

发表于 | 分类于

OWL是什么

从odoo 14.0开始，Odoo官方又一次更换了前端技术，推出了新一代的前端框架OWL(Odoo Web Libary)。OWL从odoo独立出来，成为了一个独立的前端框架。其特点是包含一个组件声明系统、基于钩子的响应系统、默认的并发支持和一个存储的前端路由。

为什么是OWL?

为什么odoo没有使用现有的成熟的前端框架比如React和Vue，而是要重新独立开发一套新的框架。odoo官方给出的一个长篇的理由解释。大概有如下几个理由：

  • odoo官方不想将前端技术依赖于外界的某个特定公司的产品，想要完全拥有技术的掌控权。
  • 尽管函数式编程是一种趋势，但是odoo并不想放弃一些务实的特性，比如继承。
  • React和Vue的现有的社区库，不能满足odoo动态编译延迟计算的需求。
  • odoo基于Xml布局，替换React和Vue的话要重写编译模块，费时费力且对开发者不够友好。
  • JIT编译和响应的需要
  • React和Vue的并发特性不满足Odoo前端的需求。

简而言之，就是odoo官方觉得市面上的产品没有可以直接拿来使用的，不如自己开发一套。

一个简单的例子

接下来，我们看一个简单的例子，这个例子将在页面中画一个按钮，单击按钮实现计数器自动加1:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
const { Component, useState } = owl;
const { xml } = owl.tags;

class Counter extends Component {
    static template = xml`
<button t-on-click="state.value++">
    Click Me! [<t t-esc="state.value"/>]
</button>`;

        state = useState({ value: 0 });
    }

class App extends Component {
    static template = xml`
<div>
<span>Hello Owl</span>
<Counter />
</div>`;

    static components = { Counter };
}

const app = new App();
app.mount(document.body);

首先从owl取Compent、useState和xml组件，然后定义一个Counter组件，使用内置模板，然后定义一个App，加载Counter组件，最后挂载到页面中。

实现的效果如下：

1.jpg

这样我们就完成了一个简单的OWL应用。

基础教程

接下来，我们来写一个学习应用todoApp。我们创建一个文件夹todoApp,里边包含一个index.html，app.css，app.js：

1
2
3
4
5
todoapp/
    index.html
    app.css
    app.js
    owl.js

然后编写index.html：

1
2
3
4
5
6
7
8
9
10
11
<!DOCTYPE html>
<html lang="en">
  <head>
    <meta charset="UTF-8" />
    <title>OWL Todo App</title>
    <link rel="stylesheet" href="app.css" />
    <script src="https://github.com/odoo/owl/releases/download/v1.0.11/owl.min.js"></script>
    <script src="app.js"></script>
  </head>
  <body></body>
</html>

app.js:

1
2
3
(function(){
    console.log("Hello OWL", owl.__info__.version);
})();

刷新页面，将可以从console中看到owl的版本号。

添加第一个组件

Owl应用是由组件组成的，每个应用只能有一个根组件，我们来定义一个App组件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
const {Component} = owl;
const {xml} = owl.tags;
const {whenReady} = owl.utils;

class App extends Component {
    static template = xml`<div>todo App</div>`;
}

function setup(){
    const app = new App();
    app.mount(document.body);
}

whenReady(setup);

显示一些任务

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
class App extends Component {
  static template = xml/* xml */ `
    <div class="task-list">
        <t t-foreach="tasks" t-as="task" t-key="task.id">
            <div class="task">
                <input type="checkbox" t-att-checked="task.isCompleted"/>
                <span><t t-esc="task.title"/></span>
            </div>
        </t>
    </div>`;

  tasks = [
    {
      id: 1,
      title: "buy milk",
      isCompleted: true,
    },
    {
      id: 2,
      title: "clean house",
      isCompleted: false,
    },
  ];
}

这里用到了qweb的技术，不熟的同学可以去查看相关资料。

添加一下样式

1
2
3
4
5
6
7
8
9
10
11
.task-list {
  width: 300px;
  margin: 50px auto;
  background: aliceblue;
  padding: 10px;
}

.task {
  font-size: 18px;
  color: #111111;
}

这里将完成的任务设置一下透明度，以显示区别：

1
<div class="task" t-att-class="task.isCompleted ? 'done' : ''">

对应的样式:

1
2
3
.task.done {
    opacity: 0.7;
  }

将任务抽象为子组件

任务应该抽离出来成为一个单独的子组件，拥有闭合的行为和外观。

Task组件表现为一个任务，但是它不能拥有任务的状态，状态仍然为App组件所拥有。因此，Task可以通过prop来获取数据。

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
40
41
42
43
44
45
46
47
48
49
50
51
52
// -------------------------------------------------------------------------
// Task Component
// -------------------------------------------------------------------------
const TASK_TEMPLATE = xml /* xml */`
    <div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
        <input type="checkbox" t-att-checked="props.task.isCompleted"/>
        <span><t t-esc="props.task.title"/></span>
    </div>`;

class Task extends Component {
    static template = TASK_TEMPLATE;
    static props = ["task"];
}

// -------------------------------------------------------------------------
// App Component
// -------------------------------------------------------------------------
const APP_TEMPLATE = xml /* xml */`
    <div class="task-list">
        <t t-foreach="tasks" t-as="task" t-key="task.id">
            <Task task="task"/>
        </t>
    </div>`;

class App extends Component {
    static template = APP_TEMPLATE;
    static components = { Task };

    tasks = [
        {
          id: 1,
          title: "buy milk",
          isCompleted: true,
        },
        {
          id: 2,
          title: "clean house",
          isCompleted: false,
        },
      ];
}

// -------------------------------------------------------------------------
// Setup code
// -------------------------------------------------------------------------
function setup() {
    owl.config.mode = "dev";
    const app = new App();
    app.mount(document.body);
}

whenReady(setup);
  • 当我们定义一个子组件时，我们需要将它添加到components中。
  • Task中有一个props属性，它仅用于验证目的。
  • 仅当Owl的状态为dev时，验证机制才会生效。生产记得将dev去掉，否则会影响性能。

添加任务1

目前我们还是硬编码的任务，现在，我们将把任务的添加权限交还给用户：

1
2
3
4
5
6
7
8
<div class="todo-app">
    <input placeholder="Enter a new task" t-on-keyup="addTask"/>
    <div class="task-list">
        <t t-foreach="tasks" t-as="task" t-key="task.id">
            <Task task="task"/>
        </t>
    </div>
</div>
1
2
3
4
5
6
7
8
9
10
11
addTask(ev) {
    // 13 is keycode for ENTER
    if (ev.keyCode === 13) {
        const title = ev.target.value.trim();
        ev.target.value = "";
        console.log('adding task', title);
        // todo
    }
}

tasks=[]

t-on-keyup绑定了按键事件，当用户按下enter键时，将任务名称输出到控制台中。
然后我们给input添加一个自动的焦点:

1
2
3
4
5
6

inputRef = useRef("add-input");

mounted(){
    this.inputRef.el.focus();
}

添加任务2

目前为止，我们仅仅添加了控制台的输出，并没有将任务真正添加到页面中，接下来，我们将把任务真正地插入到列表中。

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

class App extends Component {
    static template = APP_TEMPLATE;
    static components = { Task };

    nextId = 1;
    tasks = [];

    addTask(ev) {
        // 13 is keycode for ENTER
        if (ev.keyCode === 13) {
            const title = ev.target.value.trim();
            ev.target.value = "";
            console.log('adding task', title);

            if (title) {
                const newTask = {
                    id: this.nextId++,
                    title: title,
                    isCompleted: false
                };
                this.tasks.push(newTask);
                console.log(this.tasks);
            }
        }
    }

    inputRef = useRef("add-input");

    mounted() {
        this.inputRef.el.focus();
    }

    // tasks = []
}

运行后你会发现，任务并没有如我们期望的那样显示在界面中，但是打开console你会发现，代码如期地运行了。这里的问题在于owl不知道何时应该重新渲染页面，我们可以使用useState这个钩子来使tasks变得更reactive。

1
2
3
4
5
// on top of the file
const { useRef, useState } = owl.hooks;

// replace the task definition in App with the following:
tasks = useState([]);

改变任务状态

虽然我们可以在界面上添加任务并显示出来了，但是我们又发现了新问题：勾选了任务，并没有改变透明度。原因是没有改变任务的isCompleted属性。

这里有个问题，任务是由Task组件显示出来的，但是它并不是控件状态的所有者，我们需要与它的父控件App交互，我们可以在Task中触发事件，并在App中进行监听。

1
<input type="checkbox" t-att-checked="props.task.isCompleted" t-on-click="toggleTask"/>

input控件中添加对单击事件的监听。

1
2
3
toggleTask(ev) {
        this.trigger('toggle-task', { id: this.props.task.id });
    }

将task中的触发事件继续向上传递，在App中

1
<div class="task-list" t-on-toggle-task='toggleTask'>
1
2
3
4
toggleTask(ev) {
    const task = this.tasks.find(t => t.id == ev.detail.id);
    task.isCompleted = !task.isCompleted;
}

这样就实现了完成的任务透明度变浅的效果。

添加删除按钮

接下来，我们添加一个删除按钮：

1
2
3
4
5
<div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
    <input type="checkbox" t-att-checked="props.task.isCompleted" t-on-click="toggleTask"/>
    <span><t t-esc="props.task.title"/></span>
    <span class="delete" t-on-click="deleteTask">🗑</span>
</div>

添加按钮删除事件:

1
2
3
deleteTask() {
    this.trigger('delete-task', {id: this.props.task.id});
}

在App中监听delete-task事件:

1
<div class="task-list" t-on-toggle-task="toggleTask" t-on-delete-task="deleteTask">
1
2
3
4
deleteTask(ev) {
    const index = this.tasks.findIndex(t => t.id === ev.detail.id);
    this.tasks.splice(index, 1);
}

Store

Owl Store是Owl应用状态的管理中心，由React Redux and VueX开发。

使用Store重构的代码：

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
const { Component, Store } = owl;
const { xml } = owl.tags;
const { whenReady } = owl.utils;
const { useRef, useDispatch, useStore } = owl.hooks;

//
// Store
//
const actions = {
    addTask({ state }, title) {
        title = title.trim();
        if (title) {
            const task = {
                id: state.nextId++,
                title: title,
                isCompleted: false
            };
            state.tasks.push(task);
        }
    },

    toggleTask({ state }, id) {
        const task = state.tasks.find((t) => t.id === id);
        task.isCompleted = !task.isCompleted;
    },

    deleteTask({ state }, id) {
        const index = state.tasks.findIndex((t) => t.id === id);
        state.tasks.splice(index, 1)
    }
};

const initialState = {
    nextId: 1,
    tasks: [],
};



// -------------------------------------------------------------------------
// Task Component
// -------------------------------------------------------------------------
const TASK_TEMPLATE = xml /* xml */`
<div class="task" t-att-class="props.task.isCompleted ? 'done' : ''">
<input type="checkbox" t-att-checked="props.task.isCompleted"
        t-on-click="dispatch('toggleTask', props.task.id)"/>
<span><t t-esc="props.task.title"/></span>
<span class="delete" t-on-click="dispatch('deleteTask', props.task.id)">🗑</span>
</div>`;

class Task extends Component {
    static template = TASK_TEMPLATE;
    static props = ["task"];
    dispatch = useDispatch();
}

// -------------------------------------------------------------------------
// App Component
// -------------------------------------------------------------------------
const APP_TEMPLATE = xml /* xml */`
    <div class="todo-app">
    <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
    <div class="task-list">
        <t t-foreach="tasks" t-as="task" t-key="task.id">
            <Task task="task"/>
        </t>
    </div>
    </div>`;

class App extends Component {
    static template = APP_TEMPLATE;
    static components = { Task };

    inputRef = useRef("add-input");
    tasks = useStore((state) => state.tasks);
    dispatch = useDispatch();

    mounted() {
        this.inputRef.el.focus();
    }

    addTask(ev) {
        if (ev.keyCode == 13) {
            this.dispatch("addTask", ev.target.value);
            ev.target.value = ""
        }
    }
}

// -------------------------------------------------------------------------
// Setup code
// -------------------------------------------------------------------------
function setup() {
    owl.config.mode = "dev";
    const store = new Store({ actions, state: initialState });
    App.env.store = store;
    const app = new App();
    app.mount(document.body);
}

whenReady(setup);

本地化存储任务

目前，我们的任务管理应用可以正常地增删，只是如果一旦刷新浏览器，数据就没了。接下来，我们将任务进行本地化存储:

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

function makeStore() {
    const localState = window.localStorage.getItem("todoApp");
    const state = localState ? JSON.parse(localState) : initialState;
    const store = new Store({ state, actions });
    store.on("update", null, () => {
        localStorage.setItem("todoApp", JSON.stringify(store.state));
    })
    return store;
}

function setup() {
    owl.config.mode = "dev";
    // const store = new Store({ actions, state: initialState });
    // App.env.store = store;
    App.env.store = makeStore();
    const app = new App();
    app.mount(document.body);
}

过滤任务

最后，我们希望给这个这个应用增加一个过滤系统，可以根据任务的状态进行过滤：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// on top of file, readd useState:
const { useRef, useDispatch, useState, useStore } = owl.hooks;

// in App:
filter = useState({value: "all"})

get displayedTasks() {
    switch (this.filter.value) {
        case "active": return this.tasks.filter(t => !t.isCompleted);
        case "completed": return this.tasks.filter(t => t.isCompleted);
        case "all": return this.tasks;
    }
}

setFilter(filter) {
    this.filter.value = filter;
}

在页面中显示过滤按钮:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<div class="todo-app">
    <input placeholder="Enter a new task" t-on-keyup="addTask" t-ref="add-input"/>
    <div class="task-list">
        <t t-foreach="displayedTasks" t-as="task" t-key="task.id">
            <Task task="task"/>
        </t>
    </div>
    <div class="task-panel" t-if="tasks.length">
        <div class="task-counter">
            <t t-esc="displayedTasks.length"/>
            <t t-if="displayedTasks.length lt tasks.length">
                / <t t-esc="tasks.length"/>
            </t>
            task(s)
        </div>
        <div>
            <span t-foreach="['all', 'active', 'completed']"
                t-as="f" t-key="f"
                t-att-class="{active: filter.value===f}"
                t-on-click="setFilter(f)"
                t-esc="f"/>
        </div>
    </div>
</div>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
.task-panel {
  color: #0088ff;
  margin-top: 8px;
  font-size: 14px;
  display: flex;
}

.task-panel .task-counter {
  flex-grow: 1;
}

.task-panel span {
  padding: 5px;
  cursor: pointer;
}

.task-panel span.active {
  font-weight: bold;
}

至此，我们就使用OWL完成了一个简单应用的编写。

发表于 | 分类于

odoo14要求python的版本大于3.7，因此我们需要先安装python3.7

1
sudo apt-get install python3.7

然后安装python3.7的虚拟环境

1
sudo apt-get install python3.7-venv

安装依赖:

1
pip3 install -r requirements.txt  -i https://pypi.douban.com/simple

发表于 | 分类于

不定期更新

Odoo14 发布在即，今天我们来看一下14版本发生了哪些变化，由于目前笔者还没拿到企业版，下面说的均是社区版。

内置了原生两步验证

之前的版本需要安装第三方模块来实现，如今官方已经内置集成了两步验证。

reCAPTCHA

内置了Google防机器人插件

开发者模式视图内置权限和记录规则快捷方式

新的前端开发框架Owl

https://odoo.github.io/owl/

发表于 | 分类于

首先恭喜在忙碌了一个半月之后，客户北京某动漫行业初创公司二期项目顺利毕业。本文主要回顾和总结一下客户需求及实现的思路和方案，以供广大读者参考。

客户需求

客户M是互联网平台在线动漫的供应商，主要给腾讯动漫等平台供稿，创作人员多为外包形式，因此项目的组织进度、绩效考核和费用结算就成为了HR每月底的重头戏。客户希望可以借助Odoo解决这些痛点，实现项目任务的在线分发、自动流转同时可以对各个阶段的人员的工作KPI进行考核、以及月底的薪酬的统计和发放。

整个项目分为多个部分，阶段主要是包含动漫产业流程的各个阶段，每个人负责一个阶段，一个阶段在完成以后要自动流转到下一个阶段的负责人那里，实现自动通知。计价系统负责对每个任务的价格核定，并根据任务的完成情况对考核人员进行评级，最终得出一个应付的价格。考核系统就是根据任务的完成情况、整体的流畅度等因素得出一个得分。结算系统负责每个月对所有人员当月内完成的任务进行统计，实现薪酬的自动计算，节省人工核算成本。HR系统主要是对人员的管理，在线签约、入/离职等流程管理等功能。

项目亮点

多平台管理

客户拥有多个发布平台，因此必须要在项目的基础上再抽象出来一个平台概念。同时由于每个平台的业务不同，类型不同、定价单位和定价方式，考核标准也不尽相同，要做到灵活可变，因此给平台新增了很多特性：

根据每个平台的特点，用户可以引入不同的项目阶段，并指定不同的考核标准和定价。

考核自动评价

人员在接到任务以后，系统会自动发出邮件通知。并会在任务结束时根据完成时间确定该任务是否准时完成，并将延期情况计入评分系统。

任务完成以后，由考核人员对该阶段任务做出考核结果评价，根据评价，自动计算出该任务的得分和应得薪酬。

自动结算

每个月末，系统管理员可以根据上个月的业务情况，安排自动运行项目结算任务，系统将自动根据每个人员的考核结果自动计算出应得的薪酬。

项目难点

根据整体需求，使用了odoo自动的项目管理功能，并在它的基础上进行了扩展。整个项目的难点在于，客户的平台有多个，设计的业务也有多种类型，每个作品的阶段以及定价方式、考核标注各不相同。考虑到以后的拓展性，不能将各个参数固化到代码中，因此必须以一种灵活可变的方式将各个平台的业务统一起来。

这里采用了动态编码的方式，即将项目的动态因素以规则的方式放到设置中，而此规则可以在系统中以伪代码的形式存储，客户可以根据自己的需求动态调整计算逻辑，而无需开发人员介入。

说的比较抽象，这里我们简单举一个例子：

某平台T有一个作品P，P有N个阶段: 给稿、翻译、校对、制作、监制、交稿等阶段，我们要实现不同阶段的任务评分不一样，考核标注也不同。

我们这里拓展了阶段，加入了考核标准，每个考核标准的量化参数都可以自定义，每个量化参数的计算规则都可以在线编辑，以伪代码的方式参与到计算中。

这里的伪代码，实际上是通过Python的eval函数实现的，目的主要就是为了避免因为后期考核/计价逻辑的改变而需要重构代码，只要客户学会了简单的Python脚本，就可以实现计算逻辑的动态可变。

问题总结

由于客户并非专业产品人员，对Odoo也并非特别熟悉，因此整个项目的推进没有预期的那么顺利，很多东西都是在做的时候才发现不能做，因此耽误了很多工期。项目开始之前，客户只是有一个模糊的大概的东西，具体会做成什么样子其实也没底，因此也不能一直停留在沟通阶段，很多时候，客户并不清楚自己想要的是什么，这个时候你就给他一个方案，他在看了你的方案之后会知道是不是自己想要的，然后我们再在这个基础上进行调整和优化。

发表于 | 分类于

本文假设读者已经了解odoo路线的推拉规则

路线规则的优先级

我们知道，odoo中的路线可以在四个地方设置，分别是产品路线、产品分类路线、仓库路线和订单明细行中的路线。这四种路线的优先级为:

1
销售订单明细行 ——> 产品路线——> 产品分类路线——> 仓库路线

这个很好理解，当几个路线对某个库位设置的规则冲突时，依据本优先级进行应用。现在问题来了，我们知道产品路线中有多个路线可以选择，当产品路线中的多个路线的多个规则定义了相同的库位的规则时，会怎样呢？

隐藏的规则

相同级别的路线如果定义了相同的库位规则，官方并没有给出文档解释，我们从代码中可以窥见这隐秘的规则：

我们知道在早期的版本中，驱动销售产生采购、生产单的背后的大佬是需求单(procurement.order)，到了13.0中已经演变成了procurement.group，需求单也不复存在，而且这家伙并不为普罗大众所熟知，造成的结果就是，很容易陷在路线的泥潭里而百思不得其解。

我们先来看procurement.group中是如何运行路线规则的：

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
@api.model
def run(self, procurements):
    """ Method used in a procurement case. The purpose is to supply the
    product passed as argument in the location also given as an argument.
    In order to be able to find a suitable location that provide the product
    it will search among stock.rule.
    """
    actions_to_run = defaultdict(list)
    errors = []
    for procurement in procurements:
        procurement.values.setdefault('company_id', self.env.company)
        procurement.values.setdefault('priority', '1')
        procurement.values.setdefault('date_planned', fields.Datetime.now())
        if (
            procurement.product_id.type not in ('consu', 'product') or
            float_is_zero(procurement.product_qty, precision_rounding=procurement.product_uom.rounding)
        ):
            continue
        rule = self._get_rule(procurement.product_id, procurement.location_id, procurement.values)
        if not rule:
            errors.append(_('No rule has been found to replenish "%s" in "%s".\nVerify the routes configuration on the product.') %
                (procurement.product_id.display_name, procurement.location_id.display_name))
        else:
            action = 'pull' if rule.action == 'pull_push' else rule.action
            actions_to_run[action].append((procurement, rule))

    ...

由此可见，关键方法_get_rule负责根据需求寻找对应的路线规则。所以，我们来看一下 _get_rule的具体内容:

1
2
3
4
5
6
7
8
9
10
11
12
@api.model
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 = self._get_rule_domain(location, values)
        result = self._search_rule(values.get('route_ids', False), product_id, values.get('warehouse_id', False), domain)
        location = location.location_id
    return result

这里有两个方法，_get_rule_domain负责查找库位的domain，_search_rule负责根据传入的库位查找规则。_get_rule_domain的功能比较简单，就是在规则中查找源库位为location_id且不是推式物流的规则。而_search_rule才是真正查找路线规则的关键先生。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
@api.model
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

这个方法印证了我们之前的结论:

  1. odoo会先查找给定的路线，如果没有指定路线，则在产品路线或者产品分类路线中查找，如果没有则在仓库的路线中查找。
  2. 相同优先级的路线规则，则依据规则的route_sequence和sequene进行排序，取第一个规则。

实际中的例子

其实关于odoo路线的讨论文章已经不少了，今天之所以会重新总结一遍，是因为在实际使用过程中又一次在这里摔了跟头。简单回顾一下问题发生的过程:

  1. 首先，odoo中制造的路线，默认的生产库位为WH/Stock。
  2. 因为某种原因，我们把Stock改成了视图库位，并在其下设置了很多内部库位。
  3. 销售某产品，产品路线设置MTO和Manufacture。生成的生产单无法完成，因为目的库位Stock为视图。
  4. 修改Manufacture的路线规则，将成品库位设置为Stock/A.
  5. 报错，提示在Input库位没有找到合适的路线规则。
  6. 一脸懵逼，怎么会跟Input库位有关系，经排查，产品分类中设置了两步入库、两步出库，两步出库第二步Stock->Output后，Stock为目的库位的规则只有一个，就是两步入库中的Input-> Stock，因为产品没有选购买，因此找不到Input的下一步规则。
  7. 发现错误，新增Stock/A->Output的规则到Manufacture, 并没有生效。
  8. 查看代码，发现优先级问题，调整规则的优先级，成功。

排查的过程真是耗费了大量的时间，因此为了节省时间作为以后排查的依据，整理的结论如下：

路线规则

  1. 销售订单明细行 ——> 产品路线——> 产品分类路线——> 仓库路线
  2. 路线规则的优先级，首先看路线的序号，然后看规则的序号，取找到的第一个规则应用。

思考题

不知道你是否想过 官方的原生的MTO路线是如何实现的？如果让你手动定义一个MTO路线，你会怎么定义？

本例中，如何设置Stock/A->Output的规则，可以实现销售单做完以后，生成两步出库单，并自动在Stock/A上生成生产单？