odoo13学习--20 远程过程调用Odoo
远程过程调用Odoo
Odoo服务器支持远程过程调用(RPC)，这意味着您可以从外部应用程序连接Odoo实例。使用Odoo RPC API，您可以在数据库上执行任何CRUD操作。Odoo RPC不限于CRUD操作;您还可以调用任何模型的公共方法。当然，您需要具有正确的访问权限才能执行这些操作，因为RPC尊重您在数据库中定义的所有访问权限和记录规则。因此，使用非常安全。Odoo RPC不是平台依赖性的，所以你可以在任何平台上使用它，包括Odoo。sh、在线或自托管平台。Odoo RPC可以与任何编程语言一起使用，因此您可以集成Odoo与任何外部应用程序。
Odoo提供两种类型的RPC API-XML-RPC和JSON-RPC。在本教程中，我们将学习如何从外部程序中使用这些rpc。最后，您将通过OCA的odoorpc库学习如何使用Odoo RPC。
在本章中，我们将介绍以下配置:
- 登录/连接Odoo与XML-RPC
- 通过XML-RPC搜索/读取记录
- 通过XML-RPC创建/更新/删除记录
- 通过XML-RPC调用方法
- 登录/连接Odoo与JSON-RPC
- 通过JSON-RPC获取/搜索记录
- 通过JSON-RPC创建/更新/删除记录
- 通过JSON-RPC调用方法
- OCA odoorpc库
技术要求
在本章中，我们将使用my_library模块，它是我们在第19章使用Odoo.sh管理、部署和测试中创建的。您可以在GitHub知识库上找到相同的初始my_library模块:https:// github.com/PacktPublishing/Odoo-12-Development-Cookbook-Third- Edition/tree/master/Chapter20/r0_initial_module。在这里，我们不会介绍一种新的语言，因为读者可能不熟悉它。我们将继续使用Python访问RPC API。如果您愿意，您可以使用另一种语言，因为可以在任何语言中应用相同的过程来访问RPC。
要通过RPC连接Odoo，您将需要一个运行的Odoo实例来连接。在本章中，我们将假设您的Odoo服务器运行在http://localhost:8069上，并调用test-12数据库，并且您已经在其中安装了my_library模块。注意，您可以通过RPC连接任何有效的IP或域。
请查看下面的视频，查看代码的实际操作:http://bit.ly/2UJTJZT
-
使用XMLRPC登录/连接Odoo
在本内容中，我们将通过RPC进行用户身份验证，以检查凭证是否有效。
做好准备
要通过RPC连接Odoo实例，您将需要一个正在运行的Odoo实例进行连接。 我们将假设您具有在http://localhost:8069上运行的Odoo服务器，并且已经安装了my_library模块。
怎么做...
执行以下步骤以通过RPC进行用户身份验证：
1.添加odoo_authenticate.py文件。 您可以将此文件放在任何地方您需要，因为RPC程序将独立运行。
2.将以下代码添加到文件中：
from xmlrpc import client
server_url = 'http://localhost:8069'
db_name = 'test-12'
username = 'admin'
password = 'admin'
common = client.ServerProxy('%s/xmlrpc/2/common' % server_url)
user_id = common.authenticate(db_name, username, password, {})
if user_id:
print("Success: User id is", user_id)
else:
print("Failed: wrong credentials")
3.使用以下命令从终端运行以下Python脚本：
python3 odoo_authenticate.py
这个怎么运作...
在本内容中，我们使用Python xmlrpc库通过XML-RPC访问Odoo实例。 这是一个标准的Python库，您无需安装其他任何东西即可使用它。
为了进行身份验证，Odoo在/xmlrpc/2/common端点上提供了XML-RPC。此端点用于不需要身份验证的元方法。 authentication()方法本身是一个公共方法，因此可以被公共调用。 Authentication方法接受四个参数-数据库名称，用户名，密码和用户代理环境。 用户代理环境是强制性参数，但是如果您不想传递用户代理参数，则至少传递空字典。
使用所有有效参数执行authenticate()方法时，它将调用Odoo服务器并执行身份验证。 如果给定的登录ID和密码正确，它将返回用户ID。 如果用户不存在或密码错误，它将返回False。
通过RPC访问任何数据之前，您需要使用authenticate方法。 这是因为使用错误的凭据访问数据将产生错误。 此外，用于访问数据的方法需要用户ID而不是用户名，因此需要身份验证方法才能获取用户的ID。
Odoo的在线实例（* .odoo.com）使用OAuth身份验证,因此未在实例上设置本地密码。 使用XMLRPC在这些情况下，您需要设置用户密码.从实例的Settings | Users | Users菜单中手动设置。
还有更多...
/xmlrpc/2/common端点提供了另一种方法：version(). 您可以在没有凭据的情况下调用此方法。 它将返回Odoo实例的版本信息。 以下是version()方法用法的示例：
from xmlrpc import client
server_url = 'http://localhost:8069'
common = client.ServerProxy('%s/xmlrpc/2/common' % server_url)
version_info = common.version()
print(version_info)
-
通过XMLRPC搜索/读取记录
在本内容中，我们将看到如何通过RPC从Odoo实例中获取数据。 用户可以访问大多数数据，但受安全访问控制和记录规则限制的数据除外。 RPC可以在许多情况下使用，例如收集数据进行分析，一次处理大量数据或获取数据以在另一软件/系统中显示。 有无数种可能性，您可以在必要时使用RPC。
做好准备
我们将创建一个Python程序来从library.book模型中获取图书数据。 确保已安装my_library模块，并且服务器正在http://localhost:8069上运行。
怎么做...
执行以下步骤，以通过RPC获取图书的信息：
1.添加books_data.py文件。 您可以将此文件放置在任何位置,因为RPC程序将独立运行。
2.将以下代码添加到文件中：
from xmlrpc import client
server_url = 'http://localhost:8069'
db_name = 'test-12'
username = 'admin'
password = 'admin'
common = client.ServerProxy('%s/xmlrpc/2/common' % server_url)
user_id = common.authenticate(db_name, username, password, {})
models = client.ServerProxy('%s/xmlrpc/2/object' % server_url)
if user_id:
search_domain = ['|', ['name', 'ilike', 'odoo'], ['name','ilike', 'sql']]
books_ids = models.execute_kw(db_name, user_id, password,'library.book', 'search',[search_domain],{'limit': 5})
print('Books ids found:', books_ids)
books_data = models.execute_kw(db_name, user_id, password,'library.book', 'read',[books_ids, ['name', 'date_release']])
print("Books data:", books_data)
else:
print('Wrong credentials')
3.使用以下命令从终端运行Python脚本：
python3 books_data.py
前面的程序将获取书籍数据，并提供以下输出（根据您的数据，输出可能会有所不同）：
- 数据库名称
- 用户ID（我们通过authenticate方法获得）
- 密码
- 型号名称，例如res.partner，library.book
- 方法名称，例如search，read，create
- 位置参数数组
- 关键字参数字典（可选）
在我们的示例中，我们要获取图书的信息。这可以通过search()和read()的组合来完成。书籍信息存储在library.book模型中，因此在execute_kw()中，我们使用library.book作为模型名称，并使用search作为方法名称。这将调用ORM的搜索方法并返回记录ID。唯一的区别是，ORM的搜索方法返回一个记录集，而此搜索方法返回一个ID列表。
在execute_kw()中，可以为提供的方法传递参数和关键字参数。 search()方法接受域作为位置参数，因此我们传递了一个域来过滤书籍。搜索方法还有其他可选的关键字参数，例如limit，offset，count和order，我们使用limit参数仅从中提取五个记录。这将返回名称包含odoo或SQL字符串的书籍ID的列表。尽管如此，我们仍需要从数据库中获取图书数据。我们将使用read方法执行此操作。 read方法接受ID和字段的列表以完成任务。在第3步结束时，我们使用了从搜索方法中收到的书籍ID的列表，然后使用书籍ID来获取书籍的名称和release_date。这将返回字典列表以及该书的信息。
请注意，传入的参数和关键字参数execute_kw()基于传递的方法。 您可以通过execute_kw()使用任何公共ORM方法。 您只需要提供方法名称，有效参数和关键字参数。 这些参数将在ORM的方法中传递。
还有更多...
通过search()和read()方法的组合获取的数据会稍微耗时，因为它将进行两次调用。 search_read是获取数据的另一种方法。 您可以在一个调用中搜索和获取数据。 这是使用search_read()获取书籍数据的另一种方法。
它将返回与前面的示例相同的输出：
from xmlrpc import client
server_url = 'http://localhost:8069'
db_name = 'test-12'
username = 'admin'
password = 'admin'
common = client.ServerProxy('%s/xmlrpc/2/common' % server_url)
user_id = common.authenticate(db_name, username, password, {})
models = client.ServerProxy('%s/xmlrpc/2/object' % server_url)
if user_id:
search_domain = ['|', ['name', 'ilike', 'odoo'], ['name', 'ilike','sql']]
books_ids = models.execute_kw(db_name, user_id, password,'library.book', 'search_read',[search_domain, ['name', 'date_release']],{'limit': 5})
print('Books data:', books_ids)
else:
print('Wrong credentials')
read和search_read方法将返回id字段，即使不需要ID字段。 此外，对于many2one字段，您将获得一个由ID和显示名称组成的数组。 对于例如，create_uid many2one字段将返回如下数据：[12，'Parth Gajjar']。
通过XML-RPC创建/更新/删除记录
在上一个内容中，我们了解了如何通过RPC搜索和读取数据。 在本内容中，我们将通过RPC执行其余的CRUD操作，即创建，更新（写入）和删除（取消链接）。
做好准备
我们将创建Python程序来创建，写入和取消链接数据library.book模型。 确保已安装my_library模块并且服务器正在http://localhost:8069上运行。
怎么做...
执行以下步骤，以通过以下方式创建，编写和更新图书信息
RPC：
1.添加books_operation.py文件。 您可以将此文件放在任何地方,因为RPC程序可以独立运行。
2.将以下代码添加到文件中：
from xmlrpc import client
server_url = 'http://localhost:8069'
db_name = 'test-12'
username = 'admin'
password = 'admin'
common = client.ServerProxy('%s/xmlrpc/2/common' % server_url)
user_id = common.authenticate(db_name, username, password, {})
models = client.ServerProxy('%s/xmlrpc/2/object' % server_url)
if user_id:
# create new books
create_data = [
{'name': 'Book 1', 'release_date': '2019-01-26'},
{'name': 'Book 3', 'release_date': '2019-02-12'},
{'name': 'Book 3', 'release_date': '2019-05-08'},
{'name': 'Book 7', 'release_date': '2019-05-14'}
]
books_ids = models.execute_kw(db_name, user_id, password,'library.book', 'create',[create_data])
print("Books created:", books_ids)
# Write in existing book record
book_to_write = books_ids[1] # We will use ids of recently created books
write_data = {'name': 'Books 2'}
written = models.execute_kw(db_name, user_id, password,'library.book', 'write',[book_to_write, write_data])
print("Books written:", written)
# Delete the book record
books_to_delete = books_ids[2:] # We will use ids of recently created books
deleted = models.execute_kw(db_name, user_id, password,'library.book', 'unlink',[books_to_delete])
print('Books unlinked:', deleted)
else:
print('Wrong credentials')
3.使用给定命令从终端运行Python脚本：
python3 books_operation.py
前面的程序将创建书籍的四个记录。 更新帐簿记录中的数据，然后删除两个记录将为您提供以下输出（根据您的数据库，创建的ID可能不同）：
这个怎么运作...
在本内容中，我们通过XML-RPC执行了创建，写入和删除操作，该操作还使用了/xmlrpc/2/object端点和execute_kw方法。
从Odoo v12开始，create()方法支持在单个调用中创建多个记录。 在第2步中，我们首先用书的信息创建了一个字典。 然后，我们使用书的字典通过XML-RPC创建书的新记录。XML-RPC调用需要两个参数来创建新记录：创建方法名称和书数据。 这将在library.book模型中创建四个书记录。 在ORM中，当您创建记录时，它返回创建记录的记录集，但是，如果您创建记录RPC，它将返回ID列表。
write方法的工作方式与create方法类似。 在write方法中，您需要传递一个记录ID列表和要写入的字段值。在我们的示例中，我们更新了在第一部分中创建的书的名称。 这会将第二本书的名称从Book 3更新为Book2。这里，我们仅传递了该图书的一个ID，但是如果您想在一个调用中更新多个记录，则可以传递ID列表。
在程序的第三部分，我们删除了第一本书中创建的两本书部分。 您可以使用unlink方法和记录ID列表删除记录。程序成功执行后，您将在数据库中找到两个书记录。
还有更多...
通过RPC执行CRUD操作时，如果您无权执行该操作，则可能会生成错误。 使用check_access_rights方法，可以检查用户是否具有执行特定操作的正确访问权限。 check_access_rights方法根据用户的访问权限返回True或False值。 这是一个示例，显示用户是否有权创建图书记录：
from xmlrpc import client
server_url = 'http://localhost:8069'
db_name = 'test-12'
username = 'admin'
password = 'admin'
common = client.ServerProxy('%s/xmlrpc/2/common' % server_url)
user_id = common.authenticate(db_name, username, password, {})
models = client.ServerProxy('%s/xmlrpc/2/object' % server_url)
if user_id:
has_access = models.execute_kw(db_name, user_id, password,'library.book', 'check_access_rights',['create'], {'raise_exception': False})
print('Has create access on book:', has_access )
else:
print('Wrong credentials')
# Output: Has create access on book: True
通过XML-RPC调用方法
使用Odoo，RPC API不仅限于CRUD操作。 您还可以调用业务方法。 在本内容中，我们将调用make_available方法来更改书的状态。
做好准备
我们将创建Python程序以在library.book模型上调用make_available。 确保已安装my_library模块，并且服务器正在http://localhost:8069上运行。
怎么做...
执行以下步骤，通过RPC创建，编写和更新书籍的信息：
1.添加books_method.py文件。 您可以将该文件放置在所需的任何位置，因为RPC程序将独立运行。
2.将以下代码添加到文件中：
from xmlrpc import client
server_url = 'http://localhost:8069'
db_name = 'test-12'
username = 'admin'
password = 'admin'
common = client.ServerProxy('%s/xmlrpc/2/common' % server_url)
user_id = common.authenticate(db_name, username, password, {})
models = client.ServerProxy('%s/xmlrpc/2/object' % server_url)
if user_id:
# Create book with state draft
book_id = models.execute_kw(db_name, user_id, password,'library.book', 'create',[{'name': 'New Book', 'date_release': '2019-01-26','state': 'draft'}])
# Call make_available method on new book
models.execute_kw(db_name, user_id, password,'library.book', 'make_available',[[book_id]])
# check book status after method call
book_data = models.execute_kw(db_name, user_id, password,'library.book', 'read',[[book_id], ['name', 'state']])
print('Book state after method call:',book_data[0]['state'])
else:
print('Wrong credentials')
3.使用以下命令从终端运行Python脚本：
python3 books_method.py
前面的程序将创建一本带有草稿的书，然后我们将通过调用make_available方法来更改书的状态。 之后，我们将获取图书数据以检查图书的状态，并提供以下输出：
这个怎么运作...
您可以从RPC调用任何模式方法。 这可以帮助您执行业务逻辑而不会遇到任何副作用。 例如，您从RPC创建了销售订单，然后调用了sale.order方法的action_confirm方法。 这等效于单击销售订单表单上的“确认”按钮。
您可以调用模型的任何公共方法，但是不能从RPC调用私有方法。 以_开头的方法名称称为私有方法，例如_get_share_url()和_get_data()。
使用这些方法很安全，因为它们会通过ORM并遵循所有安全规则。 如果该方法正在访问未经授权的记录，则将生成错误。
在我们的示例中，我们使用状态草稿创建了一本书。 然后，我们再进行一次RPC调用以调用make_available方法，该方法会将工作簿状态更改为可用。 最后，我们再进行一次RPC调用以检查书的状态。 这将显示该书的状态已更改为可用。
默认情况下，内部不返回任何内容的方法将返回None。 不能从RPC使用此类方法。 因此，如果要使用RPC中的方法，请至少添加return True语句。
还有更多...
如果从方法生成异常，则在事务中执行的所有操作将自动回滚到初始状态。 这仅适用于单个事务（单个RPC调用）。 例如，假设您正在对服务器进行两个RPC调用，而第二个调用中生成了一个异常。 这个将回滚在第二个RPC调用中执行的操作。 通过第一个RPC调用执行的操作将不会回滚。 因此，您想通过RPC执行复杂的操作。 建议通过在模型中创建一个方法在单个RPC调用中执行此操作。
使用JSONRPC登录/连接Odoo
Odoo提供了另一种RPC API：JSON-RPC。 顾名思义，JSON-RPC以JSON格式工作，并使用jsonrpc 2.0规范。 在本内容中，我们将看到如何使用JSON-RPC登录。 Odoo Web客户端本身使用JSON-RPC从服务器获取数据。
做好准备
在本内容中，我们将通过JSON-RPC执行用户身份验证，以检查给定的凭据是否有效。 确保已安装my_library模块，并且服务器正在http:// localhost:8069上运行。
怎么做...
执行以下步骤以通过RPC执行用户身份验证：
1.添加jsonrpc_authenticate.py文件。 您可以将该文件放置在所需的任何位置，因为RPC程序将独立运行。
2.将以下代码添加到文件中：
import json
import random
import requests
server_url = 'http://localhost:8069'
db_name = 'test-12'
username = 'admin'
password = 'admin'
json_endpoint = "%s/jsonrpc" % server_url
headers = {"Content-Type": "application/json"}
def get_json_payload(service, method, *args):
return json.dumps({
"jsonrpc": "2.0",
"method": 'call',
"params": {
"service": service,
"method": method,
"args": args
},
"id": random.randint(0, 100000000),
})
payload = get_json_payload("common", "login", db_name,username, password)
response = requests.post(json_endpoint, data=payload,headers=headers)
user_id = response.json()['result']
if user_id:
print("Success: User id is", user_id)
else:
print("Failed: wrong credentials")
3.使用以下命令从终端运行Python脚本：
python3 jsonrpc_authenticate.py
当您运行上述程序并传递了有效的登录名和密码时，该程序将显示一条包含用户ID的成功消息，如下所示：
这个怎么运作...
JSON-RPC使用JSON格式与服务器通信。它使用/jsonrpc端点与服务器通信。在我们的示例中，我们使用Python请求包来发出POST请求，但是如果需要，您可以使用其他包，例如urllib。
JSON-RPC仅接受JSON-RPC 2.0规范中格式化的有效负载，请参阅；此链接以了解有关JSON-RPC格式https://www.jsonrpc.org/specification的更多信息。在我们的示例中，我们创建了get_json_payload()方法，该方法将以有效的JSON-RPC 2.0格式准备有效负载。此方法接受服务名称和要调用的方法，其余参数将放在* args中。我们将在所有后续内容中使用此方法。 JSON-RPC接受JSON格式的请求，并且仅当请求包含{“ Content-Type”：“ application / json”}标头时，才接受这些请求。请求的结果将为JSON格式。
像XML-RPC一样，所有公共方法（包括登录名）都属于通用服务之下，因此，我们将通用作为服务传递，并将登录名作为准备JSON有效负载的方法。登录方法需要一些额外的参数，因此我们传递了数据库名称，用户名和密码。然后，我们使用有效负载和标头向JSON端点发出POST请求。如果您传递了正确的用户名和密码，则该方法将返回用户ID。响应将采用JSON格式，您将在结果键中得到结果。
请注意，在此内容中创建的get_json_payload（）方法用于从示例中删除重复的代码。使用它不是强制性的，因此可以随意应用自己的修改。
还有更多...
像XML-RPC一样，JSON-RPC中也提供了version方法。 此版本的方法属于公共服务范围，可公开访问。 您可以获得没有登录信息的版本信息。 请参见以下示例，其中显示了如何获取Odoo服务器的版本信息：
import json
import random
import requests
server_url = 'http://localhost:8069'
json_endpoint = "%s/jsonrpc" % server_url
headers = {"Content-Type": "application/json"}
def get_json_payload(service, method, *args):
... # see full function definition in last section
payload = get_json_payload("common", "version")
response = requests.post(json_endpoint, data=payload, headers=headers)
print(response.json())
通过JSON-RPC获取/搜索记录
在上一个内容中，我们看到了如何通过JSON-RPC进行身份验证。 在本内容中，我们将看到如何使用JSON-RPC从Odoo实例获取数据。
做好准备
在本内容中，我们将使用JSON-RPC获取图书信息。 确保已安装my_library模块，并且服务器正在http:// localhost:8069上运行。
怎么做...
执行以下步骤以从library.book模型中获取书籍数据：
1.添加jsonrpc_fetch_data.py文件。 您可以将此文件放在任何地方您需要，因为RPC程序将独立运行。
2.将以下代码添加到文件中：
# place authentication and get_json_payload methods (see firstjsonrpc recipe)
if user_id:
# search for the books ids
search_domain = ['|', ['name', 'ilike', 'odoo'], ['name','ilike', 'sql']]
payload = get_json_payload("object", "execute_kw",db_name, user_id, password,'library.book', 'search', [search_domain], {'limit':5})
res = requests.post(json_endpoint, data=payload,headers=headers).json()
print('Search Result:', res) # ids will be in result keys
# read data for books ids
payload = get_json_payload("object", "execute_kw",db_name, user_id, password,'library.book', 'read', [res['result'], ['name','date_release']])
res = requests.post(json_endpoint, data=payload,
headers=headers).json()
print('Books data:', res)
else:
print("Failed: wrong credentials")
3.使用以下命令从终端运行Python脚本：
python3 jsonrpc_fetch_data.py
这个怎么运作...
在使用JSON-RPC登录/连接Odoo配方中，我们看到您可以验证用户名和密码。如果登录详细信息正确，则RPC调用将返回user_id。然后，您可以使用此user_id来获取模型的数据。像XMLRPC一样，我们需要使用搜索和读取组合来从模型中获取数据。为了获取数据，我们使用对象作为服务，并使用execute_kw作为方法。 execute_kw与我们在XML-RPC中用于数据的方法相同，因此它接受相同的参数，如下所示：
- 数据库名称
- 用户ID（我们通过authenticate方法获得）
- 密码
- 模块名称，例如res.partner，library.book
- 方法名称，例如搜索，读取，创建
- 位置参数数组（args）
- 关键字参数字典（可选）（kwargs）
在我们的示例中，我们首先调用了搜索方法。 execute_kw方法通常将强制参数作为位置参数，并将可选参数作为关键字参数。在搜索方法中，domain是强制性参数，因此我们在列表中传递了它，并传递了可选参数限制作为关键字参数（字典）。您将获得JSON格式的响应，并且在此配方中，search（）方法RPC的响应将在结果键中包含书的ID。
在第2步中，我们使用read方法进行了RPC调用。 为了阅读本书的信息，我们传递了两个位置参数-图书ID列表和要获取的字段列表。 此RPC调用将以JSON格式返回图书信息，您可以在结果键中对其进行访问。
可以使用execute作为方法，而不是execute_kw。 这不支持关键字参数，因此如果要传递一些可选参数，则需要传递所有中间参数。
还有更多...
与XML-RPC相似，您可以使用search_read（）方法代替
search（）和read（）方法的组合，因为它比较耗时。 以下是使用search_read（）获取书籍数据的另一种方法。 它将返回与上一个示例相同的输出：
# place authentication and get_json_payload methods (see first jsonrpc
recipe)
if user_id:
# search and read for the books ids
search_domain = ['|', ['name', 'ilike', 'odoo'], ['name', 'ilike','sql']]
payload = get_json_payload("object", "execute_kw",db_name, user_id, password,'library.book', 'search_read', [search_domain, ['name','date_release']],{'limit': 5})
res = requests.post(json_endpoint, data=payload, headers=headers).json()
print('Books data:', res)
else:
print("Failed: wrong credentials")
通过JSON-RPC创建/更新/删除记录
在上一个内容中，我们介绍了如何通过JSON-RPC搜索和读取数据。在本内容中，我们将通过以下方式执行其余的CRUD操作：RPC-创建，更新（写入）和删除（取消链接）。
做好准备
我们将创建一个Python程序，以在library.book模型上创建，写入和取消链接数据。 确保已安装my_library module，并且服务器正在http://localhost:8069上运行。
怎么做...
执行以下步骤以通过RPC创建，编写和取消链接图书信息：
1.添加jsonrpc_operation.py文件。 您可以将该文件放置在所需的任何位置，因为RPC程序将独立运行。
2.将以下代码添加到文件中：
# place authentication and get_json_payload method (see last recipe for more)
if user_id:
# creates the books records
create_data = [
{'name': 'Book 1', 'date_release': '2019-01-26'},
{'name': 'Book 3', 'date_release': '2019-02-12'},
{'name': 'Book 5', 'date_release': '2019-05-08'},
{'name': 'Book 7', 'date_release': '2019-05-14'}
]
payload = get_json_payload("object", "execute_kw",db_name, user_id, password, 'library.book', 'create',[create_data])
res = requests.post(json_endpoint, data=payload,headers=headers).json()
print("Books created:", res)
books_ids = res['result']
# Write in existing book record
book_to_write = books_ids[1] # We will use ids of recentlycreated books
write_data = {'name': 'Book 2'}
payload = get_json_payload("object", "execute_kw",db_name, user_id, password, 'library.book', 'write',[book_to_write, write_data])
res = requests.post(json_endpoint, data=payload,
headers=headers).json()
print("Books written:", res)
# Delete in existing book record
book_to_unlink = books_ids[2:] # We will use ids of recently created books
payload = get_json_payload("object", "execute_kw",db_name, user_id, password, 'library.book', 'unlink',[book_to_unlink])
res = requests.post(json_endpoint, data=payload,headers=headers).json()
print("Books deleted:", res)
else:
print("Failed: wrong credentials")
python3 jsonrpc_operation.py
这个怎么运作...
execute_kw用于创建，更新和删除操作。 从Odoo版本12开始，create方法支持创建多个记录。 因此，我们根据这四本书的信息准备了词典。 然后，我们以library.book作为模型名称并创建为方法名称进行JSON-RPC调用。 这将在数据库中创建四个书记录，并返回带有这些新创建的书的ID的JSON响应。 在下一个RPC调用中，我们希望使用这些ID进行更新和删除操作的RPC调用，因此我们将其分配给books_ids变量。
当您尝试创建记录而不为必填字段提供值时，JSON-RPC和XML-RPC都会生成错误，因此请确保已在创建值中添加了所有必填字段。
在下一个RPC调用中，我们使用write方法更新现有记录。 write方法接受两个位置参数。 要更新的记录和要写入的值。 在我们的示例中，我们通过使用已创建书籍ID中第二本书的ID更新了书籍的名称。 这会将第二本书的名称从Book 3更改为Book 2。
然后，我们进行了最后一个RPC调用，以删除两个帐簿记录。 为此，我们使用了unlink方法。 unlink方法仅接受一个参数，这是您要删除的记录的ID。 此RPC调用将删除最后两本书。
还有更多...
与XML-RPC一样，您可以在JSON-RPC中使用check_access_rights方法来检查您是否具有执行该操作的访问权限。 此方法需要两个参数-型号名称和操作名称。 在以下示例中，我们检查对library.book模型的create操作的访问权限：
# place authentication and get_json_payload method (see last recipefor more)
if user_id:
payload = get_json_payload("object", "execute_kw",db_name, user_id, password,'library.book', 'check_access_rights', ['create'])
res = requests.post(json_endpoint, data=payload,headers=headers).json()
print("Has create access:", res['result'])
else:
print("Failed: wrong credentials")
通过JSON-RPC调用方法
在本内容中，我们将学习如何通过JSON-RPC调用模型的自定义方法。 我们将通过调用make_available（）方法来更改书籍的状态。
做好准备
我们将创建Python程序以在library.book模型上调用make_available。 确保已安装my_library模块，并且服务器正在http:// localhost:8069上运行。
怎么做...
执行以下步骤，通过RPC创建，编写和更新书籍的信息：
1.添加jsonrpc_method.py文件。 您可以将该文件放置在所需的任何位置，因为RPC程序将独立运行。
2.将以下代码添加到文件中：
# place authentication and get_json_payload method (see last recipe for more)
if user_id:
# Create the book in draft state
payload = get_json_payload("object", "execute_kw",db_name, user_id, password,'library.book', 'create', [{'name': 'Book 1', 'state':'draft'}])
res = requests.post(json_endpoint, data=payload,headers=headers).json()
print("Has create access:", res['result'])
book_id = res['result']
# Change the book state by calling make_available method
payload = get_json_payload("object", "execute_kw",db_name, user_id, password,'library.book', 'make_available', [book_id])
res = requests.post(json_endpoint, data=payload,
headers=headers).json()
# Check the book status after method call
payload = get_json_payload("object", "execute_kw",db_name, user_id, password,'library.book', 'read', [book_id, ['name', 'state']])
res = requests.post(json_endpoint, data=payload, headers=headers).json()
print("Book state after the method call:", res['result'])
else:
print("Failed: wrong credentials")
3.使用以下命令从终端运行Python脚本：
python3 jsonrpc_method.py
前面的命令将使用草稿创建一本书，然后我们将通过调用make_available方法更改该书的状态。 之后，我们将获取图书数据以检查图书状态，这将提供以下输出：
这个怎么运作...
execute_kw可以调用模型的任何公共方法。正如我们在通过XML-RPC的Calling方法中看到的那样，公共方法是那些名称中没有用_（下划线）表示的方法。以_开头的方法是私有的，您不能从JSON-RPC调用它们。
在我们的示例中，我们使用状态草稿创建了一本书。然后，我们再进行一次RPC调用以调用make_available方法，该方法会将工作簿状态更改为可用。最后，我们再进行一次RPC调用以检查书的状态。这将显示该书的状态已更改为可用。
请注意，默认情况下，内部不返回任何内容的方法将返回None。RPC无法使用此类方法。如果要使用RPC中的方法，请至少添加return True语句。
OCA odoorpc库
Odoo社区协会（OCA）提供了一个名为odoorpc的Python库，可从https://github.com/OCA/odoorpc获得。 odoorpc库提供了一种用户友好的语法，可通过该语法通过RPC访问Odoo数据。 它提供与服务器类似的语法。 在本食谱中，我们将看到如何使用odoorpc库以通过RPC执行操作。
做好准备
odoorpc库在Python包（PyPi）索引上注册。 为了使用该库，您需要使用以下命令进行安装。 如果需要，可以在单独的虚拟环境中使用它：
pip install OdooRPC
在本内容中，我们将使用odoorpc库进行一些基本操作。 我们将使用library.book模型执行这些操作。 确保已安装my_library模块，并且服务器正在http://localhost:8069上运行。
怎么做...
执行以下步骤，通过RPC创建，编写和更新书籍的信息：
1.添加odoorpc_library.py文件。 您可以将该文件放置在所需的任何位置，因为RPC程序将独立运行。
2.将以下代码添加到文件中：
import odoorpc
db_name = 'test-12'
user_name = 'admin'
password = 'admin'
# Prepare the connection to the server
odoo = odoorpc.ODOO('localhost', port=8069)
odoo.login(db_name, user_name, password) # login
# User information
user = odoo.env.user
print(user.name) # name of the user connected
print(user.company_id.name) # the name of user's company
print(user.email) # the email of usser
BookModel = odoo.env['library.book']
search_domain = ['|', ['name', 'ilike', 'odoo'], ['name','ilike', 'sql']]
books_ids = BookModel.search(search_domain, limit=5)
for book in BookModel.browse(books_ids):
print(book.name, book.date_release)
# create the book and update the state
book_id = BookModel.create({'name': 'Test book', 'state':'draft'})
print("Book state before make_available:", book.state)
book = BookModel.browse(book_id)
book.make_available()
book = BookModel.browse(book_id)
print("Book state before make_available:", book.state)
3.使用以下命令从终端运行Python脚本：
python3 odoorpc_library.py
这个怎么运作...
安装odoorpc库后，您可以立即开始使用它。为此，您将需要导入odoorpc软件包，然后我们将通过传递服务器URL和端口来创建ODOO类的对象。这将使/version_info调用服务器以检查连接。要登录，您需要使用对象的login()方法。在这里，您需要传递数据库名称，用户名和密码。
成功登录后，您可以访问odoo.env.user中的用户信息。 odoorpc提供了一个用户友好的RPC版本，因此您可以像在服务器中的记录集一样使用此用户对象。在我们的示例中，我们从该用户对象访问名称，电子邮件和公司名称。
如果要访问模型注册表，则可以使用odoo.env对象。您可以在模型上调用任何模型方法。在后台，odoorpc库使用jsonrpc，因此您不能调用以_开头的任何私有模型方法名称。在我们的示例中，我们从注册表访问了library.book模型。之后，我们使用domain和limit参数调用了搜索方法。这将返回书籍的ID。通过将书籍ID传递给Browse（）方法，可以为library.book模型生成一个记录集。在程序的最后，我们创建了新书并通过调用make_available（）方法更改了书的状态。如果仔细查看该程序的语法，您将看到它使用与服务器相同的语法。
还有更多...
尽管它提供类似于服务器的用户友好语法，但是您可以像使用普通RPC语法一样使用该库。 为此，您需要将odoo.execute方法与模型名称，方法名称和参数一起使用。 这是使用原始RPC语法阅读书籍信息的示例：
import odoorpc
db_name = 'test-12'
user_name = 'admin'
password = 'admin'
# Prepare the connection to the server
odoo = odoorpc.ODOO('localhost', port=8069)
odoo.login(db_name, user_name, password) # login
books_info = odoo.execute('library.book', 'search_read',[['name', 'ilike', 'odoo']], ['name', 'date_release'])
print(books_info)
也可以看看
Odoo的RPC库还有其他几种实现。 以下：
https://github.com/akretion/ooor
https://github.com/OCA/odoorpc
https://github.com/odoo/openerp-client- lib
http://pythonhosted.org/OdooRPC
https://github.com/abhishek-jaiswal/php- openerp- lib
浙公网安备 33010602011771号