发表于 | 分类于

odoo本身支持多数据库还是挺方便的，再没有开启多worker的情况下，感觉还不错。随着业务量的增长，我们势必会要开启多核以发挥最大化的性能。然而，odoo的多核模式却还隐藏着若干个坑，现在我们要提到的就是多数据库模式的坑。

问题的起源

之前讲到过，我们的系统需要跟其他的系统进行对接，为了解耦，消息队列就成了一个必然的选择。在我们搭建对接完成之后，服务跑的还可以，以为万事大吉，可以不用再过多过问消息对队列的问题了。然而没想到的事，有一天有人说两个系统之间的数据不一致，根据日志发现，跑的好好的RabbitMQ，突然就断开了。具体的表现如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2019-11-19 06:53:11,381 10002 INFO ? odoo.sql_db: ConnectionPool(used=0/count=0/max=64): Closed 4 connections to 'user=odoo password=xxx dbname=erp host=172.19.0.12 port=5432 sslmode=prefer' 
2019-11-19 06:53:11,399 10002 INFO ? odoo.sql_db: ConnectionPool(used=0/count=0/max=64): Closed 1 connections to 'user=odoo password=xxx dbname=erp-dev host=172.19.0.12 port=5432 sslmode=prefer' 
2019-11-19 06:53:11,417 10002 INFO ? odoo.sql_db: ConnectionPool(used=0/count=0/max=64): Closed 1 connections to 'user=odoo password=xxx dbname=odoo host=172.19.0.12 port=5432 sslmode=prefer' 
2019-11-19 06:53:11,434 10002 INFO ? odoo.sql_db: ConnectionPool(used=0/count=0/max=64): Closed 1 connections to 'user=odoo password=xxx dbname=demo host=172.19.0.12 port=5432 sslmode=prefer' 
2019-11-19 06:53:16,247 10003 INFO erp odoo.addons.base.models.ir_cron: Starting job `Backup scheduler`. 
2019-11-19 06:53:16,273 10003 INFO erp odoo.modules.registry: Invalidating all model caches after database signaling. 
2019-11-19 06:53:16,280 10003 ERROR erp odoo.addons.base.models.ir_cron: Call from cron Backup scheduler for server action #762 failed in Job #24 
Traceback (most recent call last):
  File "/usr/lib/python3/dist-packages/odoo/addons/base/models/ir_cron.py", line 102, in _callback
--
ERROR: cursor already closed 
2019-11-19 06:55:21,297 10002 INFO ? odoo.sql_db: ConnectionPool(used=0/count=0/max=64): Closed 5 connections to 'user=odoo password=xxx dbname=erp host=172.19.0.12 port=5432 sslmode=prefer' 
2019-11-19 06:55:21,307 10002 ERROR erp odoo.addons.orssica_erp.models.consumer: Traceback (most recent call last):
  File "/home/ubuntu/odoo/odoo-dev/custom/he_addons/orssica_erp/models/consumer.py", line 127, in handler_output
    picking = picking_obj.create(picking_data)
  File "<decorator-gen-394>", line 2, in create
  File "/usr/lib/python3/dist-packages/odoo/api.py", line 430, in _model_create_single
    return create(self, arg)
  File "/home/ubuntu/odoo/odoo-dev/custom/he_addons/pos_retail/models/stock/stock_picking.py", line 15, in create
    picking = super(stock_picking, self).create(vals)
  File "<decorator-gen-194>", line 2, in create
--
psycopg2.InterfaceError: cursor already closed

从日志上分析，是原本在接收到消息之后要执行的后续动作因为数据库连接的关闭而被阻断了。为了查找连接被阻断的原因，我们查看了odoo相关的配置：

1
2
3
4
5
6
7
limit_time_cpu = 7200
limit_time_real = 7200
; limit_request = 200
workers = 4 
limit_memory_hard = 1610612736
limit_memory_soft = 4294967296  
; list_db = False

最开始以为是多核模式下的内存设置问题，后来经过几次调整，发现问题并未得到改善。显然也不是因为CPU时间问题，因为如果时CPU时间超时的错误提示并非直接关闭数据库。

源码分析

在几经搜索无果之后，只能去源码里一探究竟了。我们发现，报错之前总是伴随着数据库连接关闭。而数据库连接关闭的日志是INFO，显然这是odoo的主动行为而并非意外关闭。根据提示，我们定位到sql_db.py文件的相关代码：

1
2
3
4
5
6
7
8
9
10
11
@locked
def close_all(self, dsn=None):
    count = 0
    last = None
    for i, (cnx, used) in tools.reverse_enumerate(self._connections):
        if dsn is None or cnx._original_dsn == dsn:
            cnx.close()
            last = self._connections.pop(i)[0]
            count += 1
    _logger.info('%r: Closed %d connections %s', self, count,
                (dsn and last and 'to %r' % last.dsn) or '')

然后顺藤摸瓜地找到了：

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
def process_work(self):
    rpc_request = logging.getLogger('odoo.netsvc.rpc.request')
    rpc_request_flag = rpc_request.isEnabledFor(logging.DEBUG)
    _logger.debug("WorkerCron (%s) polling for jobs", self.pid)
    db_names = self._db_list()
    if len(db_names):
        self.db_index = (self.db_index + 1) % len(db_names)
        db_name = db_names[self.db_index]
        self.setproctitle(db_name)
        if rpc_request_flag:
            start_time = time.time()
            start_memory = memory_info(psutil.Process(os.getpid()))

        from odoo.addons import base
        base.models.ir_cron.ir_cron._acquire_job(db_name)

        # dont keep cursors in multi database mode
        if len(db_names) > 1:
            odoo.sql_db.close_db(db_name)
        if rpc_request_flag:
            run_time = time.time() - start_time
            end_memory = memory_info(psutil.Process(os.getpid()))
            vms_diff = (end_memory - start_memory) / 1024
            logline = '%s time:%.3fs mem: %sk -> %sk (diff: %sk)' % \
                (db_name, run_time, start_memory / 1024, end_memory / 1024, vms_diff)
            _logger.debug("WorkerCron (%s) %s", self.pid, logline)

        self.request_count += 1
        if self.request_count >= self.request_max and self.request_max < len(db_names):
            _logger.error("There are more dabatases to process than allowed "
                            "by the `limit_request` configuration variable: %s more.",
                            len(db_names) - self.request_max)
    else:
        self.db_index = 0

从这段代码上来看，当odoo发现你是多数据库模式，新开一个worker的时候就会把之前的worker的数据库连接关掉。这就是造成，我们之前的数据库连接被莫名其妙干掉的原因。

知道了原因，解决方案就浮出水面了。既然多数据库模式下会出现这个问题，那么我们就把多余的数据库干掉就好了。

经验与教训

多数据库模式下，新开worker会关闭所有数据库连接。因此，我们在生产环境中最好不要建里多个数据库，如果要，也要用多个postgresql的用户使之独立，再结合odoo的db_filter参数，确保_db_list方法获取到的数据库只有一个就能避免这个问题。

发表于 | 分类于

实际应用中，我们只使用odoo单一系统的概率很小，基本上都会碰到与其他系统对接的问题。通常我们采用的做法是使用API接口的方式进行调用。这种做法的缺点是实时性要求高，调用者在调用之后需等待被调用者返回结果后才可以进行下一步的动作。现在比较流行的一种解耦方式是使用消息队列，今天我们就以Rabbit MQ为例来说明如何将odoo系统与消息队列服务器通讯，并接收来自第三方系统的消息。

Rabbit MQ 与 Odoo

Rabiit MQ是一个由Erlang编写的AMQP的开源实现。关于Rabbit MQ的搭建和部署不在本篇文章的范围内，有需要的同学可以自行google。这里我们要说的是如何将Rabbit MQ与Odoo对接起来。

连接Rabbit MQ我们需要使用到Python的一个库pika，一个典型的Python连接Rabbit Mq的脚本如下：

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

credential = pika.PlainCredentials("test", "test")

conn = pika.BlockingConnection(
    pika.ConnectionParameters(host="rabbitmq.test.com", credentials=credential, heartbeat=60))
channel = conn.channel()
channel.queue_declare("test", durable=True)

def call_back(ch, method, properties, body):
    print(f"收到消息..{body.decode('utf-8')}")


channel.basic_consume("test", call_back, auto_ack=True)
channel.start_consuming()

因为监听脚本会阻断当前线程的运行，因此，我们现在需要在odoo中新开一个线程来运行rabbitmq脚本，实现对rabbit服务器的消息的持续监听。

1
2
3
4
5
6
7
8
9
10
11
def run(self):
    try:
        channel = self.get_client()
        self.state = 'running'
        _logger.info(f"运行RabbitMQ消费者:{self.name}")
        t = threading.Thread(target=channel.start_consuming)
        t.setDaemon(True)
        t.start()
    except Exception as err:
        self.state = 'stopped'
        _logger.error(f"启动线程失败：{traceback.format_exc()}")

借助于odoo自带的计划任务，我们可以将上述功能做成自动启动的脚本，当odoo服务器启动后自动连接。

为了方便移植和重用，我把这些功能做成了一个独立的模块，经过配置就可以使用了：

模块代码地址

发表于 | 分类于

odoo支持多种支付方式，国内来说最常见的莫非支付宝和微信支付了，今天我们就来手动实现一个支付宝对接模块。

沙箱环境

由于支付宝对接需要各种申请权限，好在官方提供了一个沙箱环境，我们就在沙箱环境下进行我们的开发。首先，我们用支付宝去申请一个沙箱账号：

AppID是支付宝应用必须的一个应用ID，申请应用时会自动分配一个。

然后我们需要设置应用的密钥，支付宝支持的加密方式有RSA和RSA2两种，推荐的长度是2048，我们可以使用官方的密钥生成工具来帮助我们生成两种密钥。

因为我们是Python应用，所以选择PKCS1格式。

将生成完的密钥上传到支付宝后台，密钥这步就算完成了。

另外，我们可以再下载一个安卓版的测试钱包，使用官方提供的沙箱账号登录测试。

Python SDK

支付宝的验签和请求流程可谓相当麻烦，我们这里使用自己编写的SDK包来帮助我们简化我们的开发任务。(没有使用官方SDK的原因，一方面是因为过于臃肿，另一方面官方的SDK代码一种浓浓的java味道)

Payment Alipay

各种支付方式在odoo中都是一个payment.acquirer的对象，因此我们需要继承这个对象。

provider用来指明支付提供商，这里当然就是支付宝了，因为我们是继承，所以需要再父类的基础上添加一个provider，命名为alipay。

剩下的字段就是支付宝集成需要的字段，主要包括：

  • seller_id：卖家ID 用来验证收款方ID
  • alipay_appid: 前面提到的appid
  • alipay_secret: 前面提到的密钥
  • alipay_public_key： 支付宝公钥，区别于应用公钥。应用于支付宝异步消息验签。
  • alipay_sign_type： 验签方式，RSA和RSA2
1
2
3
4
5
6
7
8
9
10
class AcquirerAlipay(models.Model):
    _inherit = 'payment.acquirer'

    provider = fields.Selection(selection_add=[('alipay', "AliPay")])
    seller_id = fields.Char("Alipay Seller Id", required=True)
    alipay_appid = fields.Char("Alipay AppId", required=True)
    alipay_secret = fields.Binary("Merchant Private Key")
    alipay_public_key = fields.Binary("Alipay Public Key")
    alipay_sign_type = fields.Selection(
        selection=[('rsa', 'RSA'), ('rsa2', 'RSA2')], string="Sign Type")

跳转支付宝付款

在Shop中有一步是选择支付方式，然后跳转支付提供方的页面进行付款。这一步在payment中是通过_get_form_action_url方法来实现的，父类会根据不同支付方式的名称不同，调用不同的子类方法，例如我们这里的支付名称是alipay，因此我们的方法名称就要命名为：alipay_get_form_action_url。

1
2
3
@api.multi
def alipay_get_form_action_url(self):
    return "/payment_alipay/jump"

我们这里只跳转到了一个中间URL，是因为有些参数只有controller中才能获取。

1
2
3
4
5
6
7
8
@http.route('/payment_alipay/jump', auth='public')
def index(self, **kw):
    """跳转至支付宝付款页面"""
    kw["csrf_token"] = request.csrf_token()
    kw["notify_url"] = self._notify_url
    alipay = request.env["payment.acquirer"].sudo().search(
        [('provider', '=', 'alipay')], limit=1)
    return redirect_with_hash(alipay._get_alipay_url(kw))

我们在web页面中购买了某项产品之后，然后点击支付按跳转到支付宝页面进行支付，支付完成后，我们需要告诉支付宝回跳到我们的网站。这个参数是通过return_url来实现的。

我们下单支付，并会跳页面，使用的是支付宝的统一收单下单并支付页面接口接口。在我们的sdk中对应的接口是trade_page_pay。

因此我们可以看到_get_alipay_url方法调用的就是trade_page_pay:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@api.model
def _get_alipay_url(self, params=None):
    """Alipay URL"""
    base_url = self.env['ir.config_parameter'].sudo(
    ).get_param('web.base.url')
    # 额外的参数
    passback_params = quote_plus("&".join(
        f"{k}={v}" for k, v in params.items() if v)) if params else None
    alipay = self._get_alipay()
    alipay.return_url = f'{base_url}{params["return_url"]}'
    alipay.notify_url = f'{base_url}{params["notify_url"]}'

    return alipay.pay.trade_page_pay(params["reference"], params["amount"],
                                        params["reference"], product_code="FAST_INSTANT_TRADE_PAY",
                                        passback_params=passback_params)

支付结果验证

支付完成后，支付宝会通过同步和异步两种方式来告诉我们支付结果。同步就是通过回跳页面中的参数，异步是在将支付结果Post到我们调用接口时传入的notify_url参数的URL。

为了保证支付结果，我们要对这两种支付结果都进行验证。

odoo中的支付过程是payment.transaction对象，我们根据支付宝返回的结果来控制payment.transaction的状态。

同步验证

同步验证就是把支付宝回传的订单号，去支付宝服务器进行查询验证，确保支付成功，如果没有支付成功，则挂起这次支付。如果异步结果在前，那么直接返回异步的结果。

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
@api.multi
def _alipay_form_validate(self, data):
    """验证支付"""
    if self.state == 'done':
        _logger.info(f"支付已经验证：{data['out_trade_no']}")
        return True
    result = {
        "acquirer_reference": data["trade_no"]
    }
    # 根据支付宝同步返回的信息，去支付宝服务器查询
    payment = self.env["payment.acquirer"].sudo().search(
        [('provider', '=', 'alipay')], limit=1)
    alipay = payment._get_alipay()
    res = alipay.pay.trade_query(out_trade_no=data["out_trade_no"])
    # 校验结果
    if res["code"] == "10000" and res["trade_status"] in ("TRADE_SUCCESS", "TRADE_FINISHED"):
        _logger.info(f"支付单：{data['out_trade_no']} 已成功付款")
        self._set_transaction_done()
    if res["code"] == "10000" and res["trade_status"] == "WAIT_BUYER_PAY":
        _logger.info(f"支付单：{data['out_trade_no']} 正等待付款...")
        self._set_transaction_pending()
    if res["code"] == "10000" and res["trade_status"] == "TRADE_CLOSED":
        _logger.info(f"支付单：{data['out_trade_no']} 已关闭或已退款.")
        self._set_transaction_cancel()
    return self.write(result)

异步验证

异步验证，需要验证支付宝推送的消息是否跟自身的匹配，校验订单信息等，如果都一致，则通过。否则挂起本次支付。

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
def _verify_pay(self, data):
    """
    验证支付宝返回的信息
    """
    alipay = self._get_alipay()
    # 验证是否符合验签逻辑
    if not alipay.comm.validate_sign(data):
        _logger.warn(f"支付宝推送支付结果验签失败：{data}")
        return False
    # 校验收款方
    if self.alipay_appid != data["app_id"]:
        _logger.warn(f"支付宝推送AppID校验失败:{data['app_id']}")
        return False
    if self.seller_id != data["seller_id"]:
        _logger.warn(f"支付宝推送卖家ID校验失败:{data['seller_id']}")
        return False
    # 校验支付信息
    transaction = self.env["payment.transaction"].sudo().search(
        [('reference', '=', data["out_trade_no"])], limit=1)
    if float(transaction.amount) != float(data["total_amount"]):
        _logger.warn(
            f"支付宝推送金额{float(transaction.amount)}与系统订单不符:{float(data['total_amount'])}")
        return False
    # 将支付结果设置完成
    if transaction.state != "done" and data["trade_status"] == "TRADE_SUCCESS":
        transaction.acquirer_reference = data["trade_no"]
        transaction._set_transaction_done()
    return True

odoo 中文翻译的一个坑

当我接入完成，付款完成之后，页面在处理支付宝返回的信息时报了一个错误：

1
not all arguments converted during string formatting

经过排查，原因出在中文翻译文件中…

有一句原文是：

1
The transaction %s with %s for %s has been confirmed. The related payment is posted: %s

居然给翻译成了：

1
%s的%s交易%s已确认。等待获取发送付款状态......

很明显，最后一个占位符被这条翻译者给吃了…

完整示例

这里是一个完整的示例：

  1. 设置支付参数：

  1. 选择商品

  1. 确认订单

  1. 填写收货信息

  1. 选择支付方式

  1. 支付宝支付

  1. 支付完成

模块开源，下载地址

发表于 | 分类于

什么是zabbix?

Zabbix是用于网络和应用程序的开源监控软件。 它提供对从服务器，虚拟机，网络设备和Web应用程序收集的数千个指标的实时监控。 这些指标可以帮助您确定IT基础架构的当前运行状况，并在客户投诉之前检测硬件或软件组件的问题。 有用的信息存储在数据库中，因此您可以随时分析数据并提高所提供服务的质量，或计划设备的升级。

Zabbix使用多种选项来收集指标，包括用户服务的无代理监控和客户端 - 服务器架构。 为了收集服务器度量标准，它使用受监视客户端上的小代理来收集数据并将其发送到Zabbix服务器。 Zabbix支持服务器和连接的客户端之间的加密通信，因此您的数据在不安全的网络上传输时受到保护。

Zabbix服务器将其数据存储在由MySQL ， PostgreSQL或Oracle提供支持的关系数据库中。 您还可以将历史数据存储在nosql数据库中，如Elasticsearch和TimescaleDB 。 Zabbix提供Web界面，因此您可以查看数据和配置系统设置。

安装

服务器环境：ubuntu 18.04
数据库： postgresql
zabbix版本： 4.4

Zabbix官方提供了快速安装的脚本，因此我们可以借助官方提供的步骤，快速安装。

官方使用的是Apache Web服务器，由于现在流行的是Nginx作前端代理，后边会使用Nginx来替代Apache

安装zabbix 仓库

1
2
3
wget https://repo.zabbix.com/zabbix/4.4/ubuntu/pool/main/z/zabbix-release/zabbix-release_4.4-1+bionic_all.deb
dpkg -i zabbix-release_4.4-1+bionic_all.deb
apt update

安装 Zabbix服务器、前端和 代理

1
apt -y install zabbix-server-pgsql zabbix-frontend-php zabbix-apache-conf php-pgsql zabbix-agent

初始化数据库

1
2
sudo -u postgres createuser --pwprompt zabbix
sudo -u postgres createdb -O zabbix zabbix

初始化数据库架构和数据：

1
zcat /usr/share/doc/zabbix-server-pgsql*/create.sql.gz | sudo -u zabbix psql zabbix

配置Zabbix连接数据库

编辑zabbix配置文件： /etc/zabbix/zabbix_server.conf

1
DBPassword=password

配置php前端

编辑apache配置文件/etc/zabbix/apache.conf中的时区:

1
php_value date.timezone Europe/Riga

重启Zabbix Server和代理进程

1
2
systemctl restart zabbix-server zabbix-agent apache2
systemctl enable zabbix-server zabbix-agent apache2

替换Web服务器为Nginx

官方默认的Web服务器是Apache，但是很多时候我们服务器上使用的是Nginx，下面我们就来将Apache服务器替换为Nginx。

安装php-fpm

首先，我们要安装php-fpm来配合Nignx的使用：

1
2
3
sudo apt-get install php7.2-fpm
sudo apt-get install php7.2-mysql php7.2-mbstring php7.2-xml
sudo apt-get install php7.2-gd php7.2-curl php7.2-bcmath php7.2-ldap

然后我们需要再像Apache配置那样配置一遍php-fpm,编辑/etc/php/7.2/fpm/php.ini:

1
date.timezone = Asia/Shanghai

记住这个配置文件，再初始化frontend时还需要再次使用。

开启fpm的9000端口

编辑配置文件：sudo vim /etc/php/7.2/fpm/pool.d/www.conf：

1
2
;listen = /run/php/php7.2-fpm.sock
listen = 127.0.0.1:9000

将端口由unix domain sock替换为 tcp socket

然后重启php-fpm:

1
sudo service php7.2-fpm restart

配置Nginx 代理

1
2
3
4
5
6
7
8
9
10
11
12
13
server
{
    listen 80;
    server_name alibaba.com;
    index  index.html index.php;
    root /usr/share/zabbix/;
    location ~ .*\.php$ {
        include fastcgi_params;
        fastcgi_pass 127.0.0.1:9000;
        fastcgi_index index.php;
        fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
    }
}

然后重载nginx:

1
nginx -s reload

配置

访问你的域名：http://xxx.com/zabbix 会让你开始配置frontend:

这里根据提示，修改php-fpm的配置文件，使之全部符合建议的要求。

配置完之后就可以登录了，zabbix默认的用户名是 Admin 密码 zabbix

在客户机上安装代理

配置完server，我们开始给需要被监控的客户机安装Agent:

Agent的安装前期和Server的一样，引入源，并更新源，之后，使用命令安装：

1
sudo apt install zabbix-agent

使用加密通信

客户端和服务器端的通讯肯定要使用加密算法，这里使用预共享密钥（PSK）来保护服务器和代理之间的连接。

首先，生成PSK:

1
sudo sh -c "openssl rand -hex 32 > /etc/zabbix/zabbix_agentd.psk"

查看密钥，并复制待用：

1
cat /etc/zabbix/zabbix_agentd.psk

密钥看起来像这样：

1
12eb854dea38ac9ee7d1ded2d74cee6262b0a56710f6946f7913d674ab82cdd4

配置代理

配置代理使用安全连接：

1
sudo vim /etc/zabbix/zabbix_agentd.conf
  1. 首先配置服务器IP
1
2
3
4
5
6
7
8
9
10
11
...
### Option: Server
#       List of comma delimited IP addresses (or hostnames) of Zabbix servers.
#       Incoming connections will be accepted only from the hosts listed here.
#       If IPv6 support is enabled then '127.0.0.1', '::127.0.0.1', '::ffff:127.0.0.1' are treated equally.
#
# Mandatory: no
# Default:
# Server=

Server=127.0.0.1

将Server值替换为你的Zabbix服务器地址.

2 . 接下来，找到配置与Zabbix服务器的安全连接的部分，并启用预共享密钥支持。 找到TLSConnect部分，如下所示：

1
2
3
4
5
6
7
8
9
10
11
### Option: TLSConnect
#       How the agent should connect to server or proxy. Used for active checks.
#       Only one value can be specified:
#               unencrypted - connect without encryption
#               psk         - connect using TLS and a pre-shared key
#               cert        - connect using TLS and a certificate
#
# Mandatory: yes, if TLS certificate or PSK parameters are defined (even for 'unencrypted' connection)
# Default:
# TLSConnect=unencrypted
...

将TLSConnect的值改为psk

  1. 同上面的步骤，给TLSPSKIdentity添加一个名称PSK 001

  2. 同上，将TLSPSKFile的值指向PSK文件地址：/etc/zabbix/zabbix_agentd.psk

保存并关闭文件。 现在，您可以重新启动Zabbix代理并将其设置为在引导时启动：

1
2
sudo systemctl restart zabbix-agent
sudo systemctl enable zabbix-agent

将客户机添加到Zabbix服务器

登陆后，点击host，然后创建主机：

然后填写主机配置：

添加模板：

模板是一些预置的监控模板，根据自己的需要进行选择。

最后，是启用加密：

发表于 | 分类于

环境：ubuntu 18.04
odoo版本： 12.0

在打印pdf报表时，分拣单条码缺失。

按照网上的方法，下载pfbfer.zip，并解压到/usr/lib/python3/dist-packages/reportlab路径下。

然而并没有效果。查看日志：

1
QSslSocket: cannot call unresolved function CRYPTO_set_locking_callback

最后google到，缺失libssl1.0-dev库

解决方案：

1
apt-get install libssl1.0-dev

总结： 别人的解决方案并不一定适用于自己，多看日志才是王道。

发表于 | 分类于

travis是GitHub上知名的ci/cd工具，我们自己编写的python库可以利用travis实现自动部署到pypi，免去了我们因为遗忘导致pypi上的开源库版本滞后的现象。

编辑.travis文件

这里假设读者已经注册了travis账号并绑定了自己的github账户，没有注册同学可以自行去注册一下。

以博主自己的开源库sf-sdk为例，首先要编写一个.travis文件：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
language: python
notifications:
  email: false
sudo: false
python:
- '3.6'
install:
- pip install -r requirements.txt
script:
- python -m sf.tests.test_order
deploy:
  provider: pypi
  user: blackcat
  on:
    python: 3.6
    tags: true
    branch: master
  password:
    secure: xMlol7prP3byFnfLgchz5rSE4xflxOOLzO9RA8sYJ5lwtDIRDW6FwZ1QaFd1tBIj1ElEFhPTN5oGUYpL344SDfVJR4QxsMVFs/A2JpU/Qno497GAPf9TFwkkRSCXGJ0U6l5s1PZQof1qNYilLQE3SJhsVC2+ZUYPEVvDxHdlMlLvx4oN7zNjgWQRXTBA3wHYWxMFTVK2UMNYUpeYdCaXu2d/Lgb1QA6SbAZMH0ldVxHLSkvJg/jDkiiJSVUle76N88ZrVa5g5s/QpQXfAnSvvsz4wPj9oSoZAhong9p5sQsA6PBXbLfCsqrDNTkn5g1bFO9OMhl0atZUYoFNPlHuMaJb+jOhMASQGZQdh/K3KIQKFf19h+l3QBg3b3wTFtwtVOj43n88SmaWgLxjWYEfXv2uBp30QQV+qgFEJwRv/K1Yc4Nzg7/VeqJVJ7om9GPsfDVpd5mOtCZO32KcknfbrL6d5sDwR5YzKMc3+Zoes9yH/8SsGCSkmSZTMsAh8uP7/XqRtMYbpnBskn6OXTIyYE5M1E6y9UPKid8Qr7aS74jZ0gTbD3IawE8XbWuOfNIbxciUmQSqaVzxjtyTVUISW3bkHJToQhgtPdHJ6/gOguiHMwWBWuN/erlmmKArsklEnWibXJ0eJXaacwDbz5bNApYWTUHcpo3Mq7XBdMJCmn0=
  • python：指定版本
  • script: 运行单元测试脚本
  • user: 填写你的pypi账号
  • password: pypi的账号，安全起见，将密码加了密

pypi密码加密

如果上面的配置使用的是明文密码，这样就把pypi账号公开了，太不安全。这里推荐使用 travis-encrypt 加密密码。

1
pip3 install travis-encrypt

然后在 .travis.yml 所在目录执行：

1
travis-encrypt --deploy block-cat sf-sdk .travis.yml

这里的block-cat和sf-sdk要替换你的GitHub账号和仓库名

构建

当你提交代码之后，会在travis看到触发ci的构建进程：

推送新版本到pypi

我们前面写的.travis中有一个条件，只有当我们推送tag到github时，才会触发部署到pypi的动作，这样就能避免因为多次提交导致pypi拒绝同版本的提交问题。

给项目添加build图标

要想让我们的项目显得bigger高一点，给自己的项目价格图标吧：

将上图中的代码贴到README.md文件中就行了。

增加测试覆盖率

首先，我们使用pytest来测试我们的测试脚本，然后使用coverage来统计覆盖率，因此，我们需要在requirements.txt文件中增加如下代码：

1
2
3
pytest
coverage
python-coveralls

同样的，我们使用github账号注册coveralls网站，添加我们的项目。

然后编辑.travis.yaml文件：

1
2
after_success:
  coveralls

再次提交我们的代码，就可以看到覆盖率了：

发表于 | 分类于

这里需要使用自己编写的顺丰模块：

注册顺丰账号

要与顺丰系统对接，首先要到顺丰API官网丰桥注册一个账号，获取clientcode和checkword。

注意，申请下来的是测试账号，只有三次调用成功以后才可以应用于生产环境。

配置系统参数

申请完账号，再系统设置中，填入你的clientcode和checkword，月结用户还需要填写月结账号。

配置发货单发货

配置完顺丰接口以后，就可以在发货单界面一键发货了：

发货成功后，顺丰单号会自动填入额外信息中的跟踪参考字段中。

定制购买

标准模块可能不符合你的要求，因此你可以选择定制你的对接模块。

本模块购买地址

关注公众号享9折优惠。

发表于 | 分类于

本文基于11.0 社区版

我们知道，odoo中的仓库管理由仓库、库位、货架等组成，其中真正用于存储货物的概念是库位和货架，在编程意义上，这两者是同一个对象，即stock.location。由于location支持层级结构，因此区分出应用意义上的库位和货架。

库位列表

如上图，Public Stock/S是一个物理库位，S-A1-1-1则代表了这个库位下的一个货架。

这样做是没有任何问题的，只是有部分客户觉得这样在进行调拨的时候，选的库位太长，比较繁琐，要求我们给加一个独立的货架功能，不影响既有系统的功能。

这个可难住宝宝们了，新增一个货架功能，牵扯到太多的内容，调拨要修改，盘库要修改，库存(stock.quant)也要修改，最麻烦的是，quant的合并和分隔逻辑一旦修改不好就会出问题。

愁坏了。

后来在晚上搜索到有人用包裹作为托盘使用的例子，受到启发，想了想似乎包裹也可以替代单层货架的功能，逻辑上没有什么大的问题

新建货架类型的包裹

首先，我们新建一个货架类型的包裹类型：

货架类型

然后我们创建以一个演示货架：

货架

入库到货架

入库到货架，只要在入库时，指定目的包裹到目标货架即可：

从货架出库

仓库内调拨和出库一样，都只需要指定源包裹为目标货架：

这样，我们就顺利解决了客户提出的问题。

发表于 | 分类于

假设有一个表A，包含两个字段id和name，表结构如下：

1
2
3
4
5
6
test=# \d test;
                     Table "public.test"
 Column |       Type        | Collation | Nullable | Default 
--------+-------------------+-----------+----------+---------
 id     | integer           |           |          | 
 name   | character varying |           |          |

现在我们往表test中插入多条重复的数据：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
test=# insert into test values (1,'小明');
INSERT 0 1
test=# insert into test values (2,'小明');
INSERT 0 1
test=# insert into test values (3,'小明');
INSERT 0 1
test=# insert into test values (4,'小李');
INSERT 0 1
test=# insert into test values (5,'小李');
INSERT 0 1
test=# insert into test values (6,'小李');
INSERT 0 1
test=# insert into test values (7,'小红');
INSERT 0 1
test=# insert into test values (8,'小红');

插入后的结果如下表：

1
2
3
4
5
6
7
8
9
10
 id | name 
----+------
  1 | 小明
  2 | 小明
  3 | 小明
  4 | 小李
  5 | 小李
  6 | 小李
  7 | 小红
  8 | 小红

现在我们的需求是删除表test中重复的数据。

不使用delete using的写法

常规的写法我们需要借助ROW_NUMBER函数，先根据name字段进行划分，根据id进行倒序排列，取其ROW_NUMBER值大于1的，将其删除，剩余就是我们需要的值。

1
2
3
delete from test where id in (
select id from 
(select id,name,ROW_NUMBER() over (partition by name order by id desc) as num from test ) as t where t.num >1);

使用delete using的写法

postgresql特有的一种写法就是使用delete using语法。

1
delete from test a using test b where a.id<b.id and a.name=b.name;

using 有点类似子查询，可以关联包含在where子语句中的字段的表。本例子中的a.id<b.id就是筛选出a表中id小于b表中id的记录。

发表于 | 分类于

碰到odoo的一个骚操作，为什么说它骚，因为我们知道，一般json请求的返回值是json，然后由前端js来处理跳转之类的动作。如果请求是http，那么跳转之类的动作由浏览器根据返回值处理。odoo这个地方骚劲在于，前端的请求是以json方式进来的，它没有返回json，而是返回了一串bytes字节，然后页面居然跳转了。

具体内部机制有待进一步探究，先把代码放这里，给以后的开发留一个思路。

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
# website_sale/controllers/main.py
@http.route(['/shop/payment/transaction/',
        '/shop/payment/transaction/<int:so_id>',
        '/shop/payment/transaction/<int:so_id>/<string:access_token>'], type='json', auth="public", website=True)
def payment_transaction(self, acquirer_id, save_token=False, so_id=None, access_token=None, token=None, **kwargs):
    """ Json method that creates a payment.transaction, used to create a
    transaction when the user clicks on 'pay now' button. After having
    created the transaction, the event continues and the user is redirected
    to the acquirer website.

    :param int acquirer_id: id of a payment.acquirer record. If not set the
                            user is redirected to the checkout page
    """
    tx_type = 'form'
    if save_token:
        tx_type = 'form_save'

    # In case the route is called directly from the JS (as done in Stripe payment method)
    if so_id and access_token:
        order = request.env['sale.order'].sudo().search([('id', '=', so_id), ('access_token', '=', access_token)])
    elif so_id:
        order = request.env['sale.order'].search([('id', '=', so_id)])
    else:
        order = request.website.sale_get_order()
    if not order or not order.order_line or acquirer_id is None:
        return False

    assert order.partner_id.id != request.website.partner_id.id

    # find or create transaction
    tx = request.website.sale_get_transaction() or request.env['payment.transaction'].sudo()
    acquirer = request.env['payment.acquirer'].browse(int(acquirer_id))
    payment_token = request.env['payment.token'].sudo().browse(int(token)) if token else None
    tx = tx._check_or_create_sale_tx(order, acquirer, payment_token=payment_token, tx_type=tx_type)
    request.session['sale_transaction_id'] = tx.id
    return tx.render_sale_button(order, '/shop/payment/validate')

tx.render_sale_button方法的返回值类似如下值：

1
2
3
4
5
<input type="hidden" name="data_set" data-remove-me="" data-action-url="/payment/transfer/feedback"/>
<input type="hidden" name="return_url" value="shop/confirmation"/>
<input type="hidden" name="reference" value="S01205"/>
<input type="hidden" name="amount" value="648"/>
<input type="hidden" name="currency" value="CNY"/>