Odoo-开发秘籍第五版-全-

Odoo 开发秘籍第五版（全）

原文：zh.annas-archive.org/md5/eff006ebae40d33cb748201c68a424ff

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

当你阅读这段文字时，你已经接触到了 Odoo，这是增长最快的开源 ERP 商业套件之一。Odoo 是一个功能齐全的开源平台，它帮助构建适用于各种行业的解决方案。如果你是开发者，你正坐在一座金矿上。如果你是最终用户，你将获得一个惊人的工具来简化你的业务流程，从售前到销售、库存和会计，一应俱全。

除了 Odoo 中可用的广泛应用程序列表，它就像一块美味的面团（嗯，这让你想起了令人垂涎的披萨吗？）可以根据你的需求进行塑形。技术上讲，它是一个非常灵活的 ORM 控制器（对象关系映射）驱动的应用程序开发框架，考虑到可扩展性而构建。遵循继承规则，功能/扩展和修改可以作为模块实现，这些模块被分类为应用程序。在这里提到 ORM，Odoo 展示了单体架构。

Odoo 17 开发食谱为开发者提供了一个坚实的平台，无论他们是初学者还是熟练者。代码片段涵盖了大多数问题和用例，解释的字段有助于准确开发模块，同时保持代码质量和可用性。作为额外的好处，第二十五章是一个特别的章节，它帮助开发者和非开发者快速生成原型。

这本书由整个 Serpent Consulting Services Pvt Ltd 团队编写和支持，每个人都贡献了自己的时间和精力，让梦想成真。

这本书面向的对象

这本书面向所有层次的开发者，需要至少了解面向对象编程，Python 是必备技能。即使是 Python 编程的新手也可以找到这本书适合。它旨在适应那些编程知识有限但强烈渴望学习的开发者。

偏好的开发编辑器是 PyCharm、Eclipse 或 Sublime，但预计大多数开发者将在基于 Ubuntu/Debian 的操作系统上运行 Odoo。代码示例有意保持简单和清晰，并配有详尽的解释，以促进理解。新手将从基础知识掌握概念，确保学习之旅愉快。

已经熟悉 Odoo 的资深开发者也应该在这本书中找到价值。它不仅增强了他们现有的知识，还提供了一个简单的方法来保持对最新 Odoo 版本的更新，其中显著的变化被突出显示。

最终，这本书旨在作为新人和资深开发者日常使用的坚实参考。此外，不同 Odoo 版本之间差异的文档将是对同时处理不同版本或移植模块的开发者有价值的资源。

这本书涵盖的内容

第一章**, 安装 Odoo 开发环境，解释了如何创建 Odoo 开发环境、启动 Odoo、创建配置文件以及激活 Odoo 的开发者工具。

第二章**, 管理 Odoo 服务器实例，提供了与从 GitHub 安装的附加组件一起工作的有用提示，以及如何组织实例的源代码。

第三章**, 创建 Odoo 附加模块，解释了 Odoo 附加模块的结构，并提供了从头开始创建简单模块的逐步指南。

第四章**, 应用模型，专注于 Odoo 模型结构，并解释了所有类型的字段及其属性。它还涵盖了通过扩展模块扩展现有数据库结构的技术。

第五章**, 基本服务器端开发，解释了在 Odoo 中执行 CRUD 操作的各种框架方法。本章还包括继承和扩展现有方法的不同方式。

第六章**, 管理模块数据，展示了如何将数据与您的模块代码一起打包。它还解释了当附加组件提供的数据模型在新版本中修改时，如何编写迁移脚本。

第七章**, 调试模块，提出了一些服务器端调试的策略，以及 Python 调试器的介绍。它还涵盖了在开发者模式下运行 Odoo 的技术。

第八章**, 高级服务器端开发技术，涵盖了 ORM 框架的更高级主题。这对于开发向导、SQL 视图、安装钩子、变更方法等非常有用。本章还解释了如何在数据库中执行原始 SQL 查询。

第九章**, 后端视图，解释了如何为您的数据模型编写业务视图以及如何从这些视图中调用服务器端方法。它涵盖了常规视图（列表视图、表单视图和搜索视图），以及一些复杂视图（看板、图形、日历、交叉表等）。

第十章**, 安全访问，解释了如何通过创建安全组、编写访问控制列表来定义给定模型上每个组可用的操作，以及在必要时编写记录级规则，来控制谁可以访问您的 Odoo 实例中的什么内容。

第十一章**, 国际化，展示了 Odoo 中语言翻译的工作方式。它展示了如何安装多种语言以及如何导入/导出翻译术语。

第十二章**, 自动化、工作流、电子邮件和打印，说明了 Odoo 中可用于实现记录业务流程的不同工具。它还展示了如何使用服务器操作和自动规则来支持业务规则。这还包括 QWeb 报告以生成动态 PDF 文档。

第十三章**, Web 服务器开发，涵盖了 Odoo Web 服务器的核心。它展示了如何创建自定义 URL 路由以在给定 URL 上提供数据，同时也展示了如何控制对这些 URL 的访问。

第十四章**, CMS 网站开发，展示了如何使用 Odoo 管理网站。它还展示了如何创建和修改美观的网页和 QWeb 模板。本章还包括如何创建具有选项的动态构建块。它包括一些专门用于管理 SEO、用户表单、UTM 跟踪、网站地图和获取访客位置信息的食谱。本章还突出了 Odoo 中多站点的最新概念。

第十五章**, Web 客户端开发，深入探讨了 Odoo 的 JavaScript 部分。它涵盖了如何创建新的字段小部件并调用服务器的 RPC。这还包括如何从头开始创建全新的视图。你还将学习如何创建入职导览。

第十六章**, Odoo Web 库（OWL），介绍了名为 OWL 的新客户端框架。它涵盖了 OWL 组件的生命周期。它还包括从头创建字段小部件的食谱。

第十七章**, 使用 Odoo 进行应用内购买，涵盖了与 Odoo 中最新 IAP 概念相关的所有内容。在本章中，你将学习如何创建 IAP 的客户和服务模块。你还将学习如何创建 IAP 账户并从最终用户那里提取 IAP 积分。

第十八章**, 自动化测试用例，包括如何编写和执行自动化测试用例。这包括服务器端和客户端测试用例。本章还涵盖了导览测试用例和设置无头 Chrome 以获取失败的测试用例的视频。

第十九章**, 使用 Odoo.sh 进行管理、部署和测试，解释了如何使用 PaaS 平台 Odoo.sh 来管理、部署和测试 Odoo 实例。它涵盖了如何管理不同类型的实例，例如生产、预发布和开发。本章还涵盖了 Odoo.sh 的各种配置选项。

第二十章**, Odoo 中的远程过程调用，涵盖了从外部应用程序连接 Odoo 实例的不同方法。本章教你如何通过 XML-RPC、JSON-RPC 和 oodoorpc 库连接到并访问 Odoo 实例的数据。

第二十一章**, 性能优化，解释了在 Odoo 中用于获得性能改进的不同概念和模式。本章包括预取、ORM 缓存和代码分析以检测性能问题。

第二十二章**, 销售点，涵盖了 PoS 应用程序中的定制。这包括用户界面的定制、添加新的操作按钮、修改业务流程和扩展客户食谱。

第二十三章**, 管理 Odoo 中的电子邮件，解释了如何在 Odoo 中管理电子邮件和聊天。它从配置邮件服务器开始，然后转向 Odoo 框架的邮件 API。本章还涵盖了 Jinja2 和 QWeb 邮件模板、表单视图中的聊天、字段日志和活动。

第二十四章**, 管理物联网盒，为您展示了物联网盒的最新硬件亮点。本章涵盖了如何配置、访问和调试物联网盒，还包括了将物联网盒与您的自定义附加组件集成的食谱。

第二十五章**, 深入探讨了模块开发的替代方法。虽然这通常不是最佳实现建议，但分析师可以使用本模块中概述的技术快速创建可能的设计、原型、报告或视图。

为了从这本书中获得最大收益

我们的主要且最有价值的建议仅仅是“实践”！每一章都提供了对开发方面的深入见解，因此应用您所学的内容至关重要。

为了充分利用这本书，我们建议您补充阅读有关 Python 编程语言、Ubuntu/Debian Linux 操作系统和 PostgreSQL 数据库的额外资源。

本书包含了 Odoo 的安装说明，因此您只需要 Ubuntu 20.04 或更高版本，或者任何其他基于 Linux 的操作系统。对于其他操作系统，您可以通过虚拟机使用它。如果您使用的是 Windows，您还可以将 Ubuntu 作为子系统安装：

本书涵盖的软件/硬件	操作系统要求
Odoo 17 + Python 3.6 及以上	Ubuntu 20.04 及以上

本书面向对 Python 编程语言有基本知识的开发者，因为 Odoo 后端运行在 Python 上。在 Odoo 中，数据文件是用 XML 创建的，因此需要具备基本的 XML 知识。

本书还涵盖了后端 JavaScript 框架、PoS 应用程序和网站构建器，这需要具备基本的 JavaScript、jQuery 和 Bootstrap 4 知识。Odoo 社区版是开源的，可以免费获取，但包括物联网、队列和仪表板在内的几个功能仅在企业版中可用，因此要跟随该食谱，您需要企业版。

要遵循第二十四章，“管理物联网盒”，您将需要 Raspberry Pi 3 Model B+，可在www.raspberrypi.org/products/raspberry-pi-3-model-b-plus/找到。

如果您正在使用本书的数字版，我们建议您亲自输入代码或从书的 GitHub 仓库（下一节中有一个链接）获取代码。这样做将帮助您避免与代码的复制和粘贴相关的任何潜在错误。

下载示例代码文件

您可以从 GitHub（github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main）下载本书的示例代码文件。如果代码有更新，它将在 GitHub 仓库中更新。

我们还有来自我们丰富的书籍和视频目录中的其他代码包，可在github.com/PacktPublishing/找到。查看它们吧！

使用的约定

本书使用了多种文本约定。

文本中的代码：表示文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称。以下是一个示例：“鉴于book是一个浏览记录，我们可以通过将book.id作为book_id参数传递来简单地回收第一个示例中的函数，以提供相同的内容。”

代码块设置如下：

@http.route('/my_library/books/json', type='json', auth='none')
def books_json(self):
records = request.env['library.book'].sudo().search([]) return records.read(['name'])

任何命令行输入或输出都按以下方式编写：

$ ./odoo-bin -d mydb --i18n-export=mail.po --modules=mail
$ mv mail.po ./addons/mail/i18n/mail.pot

粗体：表示新术语、重要单词或屏幕上看到的单词。例如，菜单或对话框中的单词以粗体显示。以下是一个示例：“另一个重要用途是提供演示数据，当数据库创建时，如果选中了加载演示数据复选框，则会加载这些数据。”

小贴士或重要注意事项

看起来像这样。

部分

在本书中，您将找到几个频繁出现的标题（准备就绪、如何做…、它是如何工作的…、更多内容…和另请参阅）。

为了清楚地说明如何完成一个菜谱，请按照以下方式使用这些部分：

准备就绪

本节告诉您在菜谱中可以期待什么，并描述了如何设置任何软件或任何为菜谱所需的初步设置。

如何做…

本节包含遵循菜谱所需的步骤。

它是如何工作的…

本节通常包含对上一节发生情况的详细解释。

另请参阅

本节提供对其他有用信息的有用链接。

联系我们

我们欢迎读者的反馈。

一般反馈：如果您对本书的任何方面有疑问，请通过电子邮件发送给我们 customercare@packtpub.com，并在邮件主题中提及书名。

勘误：尽管我们已经尽最大努力确保内容的准确性，但错误仍然可能发生。如果您在这本书中发现了错误，我们将不胜感激，如果您能向我们报告，我们将非常感谢。请访问 www.packtpub.com/support/errata 并填写表格。

盗版：如果您在互联网上发现任何形式的我们作品的非法副本，我们将不胜感激，如果您能提供位置地址或网站名称，我们将非常感谢。请通过电子邮件发送给我们 copyright@packt.com 并附上材料的链接。

如果您有兴趣成为作者：如果您在某个领域有专业知识，并且您有兴趣撰写或为书籍做出贡献，请访问 authors.packtpub.com.

分享您的想法

一旦您阅读了《Odoo 开发食谱》，我们非常乐意听到您的想法！请点击此处直接进入此书的 Amazon 评论页面并分享您的反馈。

您的评论对我们和科技社区都非常重要，并将帮助我们确保我们提供高质量的内容。

下载本书的免费 PDF 副本

感谢您购买本书！

您喜欢随时随地阅读，但无法携带您的印刷书籍到处走吗？

您选择的设备是否与您的电子书购买不兼容？

不要担心，现在，每购买一本 Packt 书籍，您都可以免费获得该书的 DRM 免费 PDF 版本。

在任何地方、任何设备上阅读。直接从您最喜欢的技术书籍中搜索、复制和粘贴代码到您的应用程序中。

优惠远不止这些，您还可以获得独家折扣、时事通讯和每日免费内容的每日电子邮件。

按照以下简单步骤获取福利：

扫描二维码或访问下面的链接

packt.link/free-ebook/9781805124276

提交您的购买证明
就这些！我们将直接将您的免费 PDF 和其他福利发送到您的电子邮件地址。

第一章：安装 Odoo 开发环境

要开始我们的 Odoo 开发之旅，我们必须通过安装源代码来设置我们的开发环境，这些源代码可以帮助我们增强、调试和改进我们的开发技能。设置 Odoo 开发环境有几种方法，但本章提出了其中最好的方法。你可以在网上找到解释其他方法的几个教程。请记住，本章是关于设置一个与生产环境有不同的要求的开发环境；生产环境需要根据系统中的数据量和用户数量设置不同的参数。我们将在本章中介绍配置文件参数及其用法。

如果你刚开始接触 Odoo 开发，你必须了解 Odoo 生态系统的某些方面。第一个食谱将为你简要介绍 Odoo 生态系统，之后我们将为开发目的安装 Odoo。

在本章中，我们将涵盖以下食谱：

理解 Odoo 生态系统
从源代码安装 Odoo
管理 Odoo 服务器数据库
将实例配置存储在文件中
激活 Odoo 开发者工具
更新附加模块列表

技术要求

本章中使用的所有代码都可以从本书的 GitHub 仓库下载，网址为 github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter01。

理解 Odoo 生态系统

Odoo 为开发者提供了开箱即用的模块化和其强大的框架帮助他们快速构建项目。在开始成为成功的 Odoo 开发者的旅程之前，你应该熟悉 Odoo 生态系统中的各种角色。

假设你有一个具有 4 个 CPU 核心、8 GB RAM 和 30 个并发 Odoo 用户的系统。

要确定所需的工作进程数，将用户数除以 6。在这种情况下，30 个用户除以 6 等于 5，这是理论上的所需工作进程数。

要计算理论上的最大工作进程数，将 CPU 核心数乘以 2 并加 1。对于 4 个 CPU 核心，(4 * 2) + 1 等于 9，这是理论上的最大工作进程数。

根据这些计算，你可以为 Odoo 用户使用 5 个工作进程，并为 cron 工作进程额外使用一个工作进程，总共 6 个工作进程。

要估计 RAM 消耗，使用以下公式：

RAM = 工作进程数 * ((0.8 * 150) + (0.2 * 1024))

在这种情况下，6 个工作进程乘以 ((0.8 * 150) + (0.2 * 1024)) 大约等于 2 GB 的 RAM。

因此，根据这些计算，Odoo 安装将需要大约 2 GB 的 RAM。

Odoo 版本

Odoo 有两个不同的版本。第一个是社区版，它是开源的，而第二个是企业版，它需要付费许可。与其他软件供应商不同，Odoo 企业版只是一个包含额外功能或新应用程序的额外应用程序包，这些应用程序添加到社区版中。企业版运行在社区版之上。社区版受通用公共许可证 v3.0（LGPLv3）的约束，并包含所有基本的企业资源规划（ERP）应用程序，如销售、客户关系管理（CRM）、发票、采购和网站构建器。或者，企业版附带 Odoo 企业版许可证，这是一个专有许可证。Odoo 企业版具有几个高级功能，如全面会计、工作室、互联网协议语音（VoIP）、移动响应式设计、电子签名、营销自动化、交付和银行集成、物联网（IoT）等。企业版还为您提供无限的错误修复支持。以下图表显示企业版依赖于社区版，这也是为什么您需要后者才能使用前者：

图 1.1 – 社区版和企业版之间的差异

您可以在此处找到两个版本的完整比较：www.odoo.com/page/editions。

注意

Odoo 在市场上所有开源 ERP 中拥有最多的社区开发者，GitHub 上有 20K+ 的分支，因此您会在应用商店中找到大量的第三方应用程序（模块）。其中一些免费应用程序使用Affero 通用公共许可证版本 3（AGPLv3）。如果您的应用程序依赖于此类应用程序，则不能在您的应用程序中使用专有许可证。具有 Odoo 专有许可证的应用程序只能在具有 LGPL 或其他专有许可证的模块上开发。

Git 仓库

Odoo 的整个代码库托管在 GitHub 上。您可以在这里发布稳定版本的错误/问题。您也可以通过提交拉取请求（PR）来提议一个新功能。Odoo 有多个仓库。以下表格提供了更多信息：

仓库	用途
`github.com/odoo/odoo`	这是 Odoo 的社区版。它对公众开放。
`github.com/odoo/enterprise`	这是 Odoo 的企业版。它仅对官方 Odoo 合作伙伴开放。
`github.com/odoo-dev/odoo`	这是一个持续开发的仓库。它对公众开放。

表 1.1 – Odoo git 仓库

每年，Odoo 发布一个主要版本，这是一个为期 3 年的长期支持版本，以及几个小版本。小版本主要用于 Odoo 的在线 master 分支正在开发中且不稳定，因此建议不要用于生产，因为它可能会破坏您的数据库。

Runbot

Runbot 是 Odoo 的自动化测试环境。每当 Odoo 的 GitHub 分支有新的提交时，Runbot 会拉取这些最新的更改，并为最后四个提交创建构建。在这里，您可以测试所有稳定和开发中的分支。您甚至可以尝试企业版及其开发分支。

每个构建都有一个不同的背景颜色，这表示测试用例的状态。绿色背景颜色表示所有测试用例都成功运行，您可以测试该分支，而红色背景颜色表示该分支上某些测试用例失败，某些功能可能在构建中损坏。您可以查看所有测试用例的日志，这些日志显示了安装过程中确切发生的事情。每个构建都有两个数据库。all 数据库安装了所有模块，而 base 数据库只安装了基础 Odoo 模块。每个构建都安装了基本的演示数据，因此您可以快速测试它，无需额外配置。

备注

您可以通过访问 runbot.odoo.com/runbot 来访问 Runbot。

以下凭证可用于访问任何 Runbot 构建：

登录 ID：admin 密码：admin
登录 ID：demo 密码：demo
登录 ID：portal 密码：portal

备注

这是一个公共测试环境，因此其他用户可能会使用/测试您正在测试的相同分支。

Odoo 应用商店

Odoo 几年前推出了应用商店，并立即受到欢迎。在撰写本文时，已有超过 39,000+ 个不同的应用程序托管在那里。您将在这里找到许多免费和付费应用程序，适用于不同版本，包括针对不同商业领域的特定解决方案，如教育、食品工业和医药。还包括扩展或为现有 Odoo 应用程序添加新功能的程序。应用商店还提供了许多美观的主题，适用于 Odoo 网站构建器。在 第三章，“创建 Odoo 扩展模块”，您将学习如何为您的自定义模块设置定价和货币。

您可以通过访问 www.odoo.com/apps 来访问 Odoo 应用商店。

您可以通过访问 www.odoo.com/apps/themes 来访问 Odoo 的主题。

备注

Odoo 在 13 版本之后开源了几个主题，现在使用了一个高级 JavaScript 脚本 OWL。我们将在 第十六章 中介绍这一点。请注意，这些在之前的版本中是付费主题。这意味着在 Odoo 的 15 和 16 版本中，您可以免费下载和使用这些美观的主题。

Odoo 社区协会

Odoo 社区协会（OCA）是一个非营利组织，负责开发和维护基于社区的 Odoo 模块。所有 OCA 模块都是开源的，并由 Odoo 社区成员维护。OCA 的 GitHub 账户包含多个用于不同 Odoo 应用的仓库。除了 Odoo 模块外，它还包含各种工具、迁移库、会计本地化等。

这里是 OCA 官方 GitHub 账户的 URL：github.com/OCA.

官方 Odoo 帮助论坛

Odoo 拥有一个非常强大的框架，只需通过使用/激活选项或遵循特定模式，就能实现许多事情。因此，如果您遇到一些技术问题或者对某些复杂案例不确定，您可以在 Odoo 官方帮助论坛上发布您的疑问。许多开发者活跃在这个论坛上，包括一些官方 Odoo 员工。

您可以通过访问www.odoo.com/forum/help-1来搜索问题或发布您的新问题。

Odoo 电子学习平台

最近，Odoo 推出了一款新的电子学习平台。该平台提供了许多视频，解释如何使用不同的 Odoo 应用。在撰写本文时，该平台没有技术视频，只有功能视频。

这里是 Odoo 电子学习平台的 URL：www.odoo.com/slides.

从源代码安装 Odoo

强烈建议您使用Linux Ubuntu操作系统来安装 Odoo，因为这是 Odoo 用于所有测试、调试和 Odoo 企业安装的操作系统。此外，大多数 Odoo 开发者使用 GNU/Linux 发行版，因此他们更有可能从 Odoo 社区获得对在GNU/Linux上发生的操作系统级别问题的支持，而不是Windows或macOS。

还建议使用与生产环境中将使用的相同环境（相同的发行版和相同的版本）来开发 Odoo 附加模块。这将避免一些令人不快的惊喜，例如在部署当天发现库的版本与预期不同，具有略微不同且不兼容的行为。如果您的工作站使用的是不同的操作系统，一个很好的方法是在工作站上设置一个虚拟机（VM），并在虚拟机中安装 GNU/Linux 发行版。

注意

Ubuntu 可以作为应用程序在Microsoft Store中获取，所以如果您不想切换到 Ubuntu，可以使用它。

对于这本书，我们将使用 Ubuntu Server 22.04 LTS，但您可以使用任何其他 Debian GNU/Linux 操作系统。无论您选择哪个 Linux 发行版，您都应该对如何从命令行使用它有所了解，并且了解系统管理肯定不会有害。

准备工作

我们假设您已经安装并运行了 Ubuntu 22.04，并且您有一个具有 root 访问权限的账户或已配置 sudo。在以下部分中，我们将安装 Odoo 的依赖项并从 GitHub 下载 Odoo 的源代码。

注意

一些配置需要系统登录用户名，因此当命令行中需要登录用户名时，我们将使用 $(whoami)。这是一个 shell 命令，它将在您输入的命令中替换您的登录名。

如果您拥有 GitHub 账户，某些操作将更容易。如果您还没有，请访问 github.com 并创建一个。

如何操作...

要从源安装 Odoo，请执行以下步骤：

运行以下命令以安装主要依赖项：

$ sudo apt-get update
$ sudo apt install openssh-server fail2ban python3-pip python3-dev libxml2-dev libxslt1-dev zlib1g-dev libsasl2-dev libldap2-dev build-essential libssl-dev libffi-dev libmysqlclient-dev libpq-dev libjpeg8-dev liblcms2-dev libblas-dev libatlas-base-dev git curl python3-venv python3.10-venv fontconfig libxrender1 xfonts-75dpi xfonts-base -y

下载并安装 wkhtmltopdf：

$ wget https://github.com/wkhtmltopdf/packaging/releases/download/0.12.6.1-2/wkhtmltox_0.12.6.1-2.jammy_amd64.deb
$ sudo dpkg -i wkhtmltox_0.12.6.1-2.jammy_amd64.deb

如果在运行上一条命令后遇到任何错误，请使用以下命令强制安装依赖项：

$ sudo apt-get install -f

现在，安装 PostgreSQL 数据库：
```
$ sudo apt install postgresql -y
```

配置 PostgreSQL：

$ sudo -i -u postgres createuser -s  $(whoami)
$ sudo su postgres
$ psql
alter user $(whoami) with password 'your_password';
\q
git:

$ git config --global user.name "Your Name"

$ git config --global user.email youremail@example.com

克隆 Odoo 代码库：

$ mkdir ~/odoo-dev
$ cd ~/odoo-dev
odoo-17.0 virtual environment and activate it:

$ python3 -m venv ~/venv-odoo-17.0

venv:

$ cd ~/odoo-dev/odoo/
$ pip3 install -r requirements.txt

创建并启动您的第一个 Odoo 实例：

$ createdb odoo-test
http://localhost:8069 and authenticate it by using the admin account and using admin as the password.

注意

如果您需要 RTL 支持，请运行以下命令安装 node 和 rtlcss：sudo apt-get install nodejs npm -y sudo npm install -``g rtlcss。

它是如何工作的...

在 步骤 1 中，我们安装了几个核心依赖项。这些依赖项包括各种工具，如 git、pip3、wget、Python 安装工具等。这些核心工具将帮助我们使用简单命令安装其他 Odoo 依赖项。

在 步骤 2 中，我们下载并安装了 wkhtmltopdf 包，该包用于 Odoo 打印 PDF 文档，如销售订单、发票和其他报告。Odoo 17.0 需要 wkhtmltopdf 的 0.12.6.1 版本，而这个确切版本可能不包括在当前的 Linux 发行版中。幸运的是，wkhtmltopdf 的维护者为各种发行版提供了预构建的包，在 wkhtmltopdf.org/downloads.html 上，我们已经从该 URL 下载并安装了它。

此后，我们配置了用于 Odoo 数据库管理的 PostgreSQL。

PostgreSQL 配置

在 步骤 3 中，我们安装了 PostgreSQL 数据库。

在 步骤 4 中，我们创建了一个新的数据库用户，登录名为我们的系统用户名。$(whoami) 用于获取您的登录名，-s 选项用于赋予超级用户权限。让我们看看为什么需要这些配置。

Odoo 使用 psycopg2 Python 库与 PostgreSQL 数据库连接。要使用 psycopg2 库访问 PostgreSQL 数据库，Odoo 默认使用以下值：

默认情况下，psycopg2 尝试连接到与本地连接上当前用户名相同的数据库，这实现了无密码认证（这对于开发环境来说很好）
本地连接使用 Unix 域套接字
数据库服务器监听端口5432

就这样！你的 PostgreSQL 数据库现在已准备好与 Odoo 连接。

由于这是一个开发服务器，我们已经给用户赋予了--superuser权限。在开发实例中，给 PostgreSQL 用户更多权限是可以的，因为这将是你开发实例。对于生产实例，你可以使用--createdb命令行代替--superuser来限制权限。在生产服务器上，--superuser权限将给攻击者利用已部署代码中某些部分的漏洞提供额外的优势。

如果你想要使用不同登录的用户数据库用户，你需要为该用户提供密码。这是通过在创建用户时在命令行上传递--pwprompt标志来完成的，在这种情况下，命令将提示你输入密码。

如果用户已经创建，并且你想设置密码（或修改忘记的密码），你可以使用以下命令：

$ psql -c "alter role $(whoami) with password 'newpassword'"

如果这个命令失败，并显示错误信息说数据库不存在，那是因为你没有在食谱的第 4 步中创建一个以你的登录名命名的数据库。没关系；只需添加--dbname选项并指定一个现有数据库的名称，例如--dbname template1。

Git 配置

对于开发环境，我们使用 GitHub 上的 Odoo。使用git，你可以轻松地在不同的 Odoo 版本之间切换。请注意，你可以使用git的pull命令获取最新的更改。

在第 5 步中，我们配置了我们的git用户。

在第 6 步中，我们从 Odoo 的官方 GitHub 仓库下载了源代码。我们使用git clone命令下载 Odoo 的源代码。我们使用单个分支，因为我们只想为 17.0 版本创建一个分支。我们还使用了--depth 1来避免下载分支的完整提交历史。这些选项将非常快速地下载源代码，但如果你愿意，可以省略这些选项。

Odoo 开发者还提出了夜间构建，这些构建作为 tar 包和分发包提供。使用git clone的主要优势是，你将能够在源树中提交新的错误修复时更新你的仓库。你还可以轻松测试任何提议的修复，并跟踪回归，以便你可以使你的错误报告更加精确和有助于开发者。

注意

如果你可以访问企业版源代码，你可以在~/odoo-dev目录下的单独文件夹中下载它。

虚拟环境

Python 虚拟环境，或简称为venvs，是隔离的 Python 工作空间。这对于 Python 开发者非常有用，因为它们允许安装不同版本的 Python 库的不同工作空间，可能是在不同的 Python 解释器版本上。

你可以使用python3 -m venv ~/newvenv命令创建任意数量的环境。这将创建一个newvenv目录在指定位置，包含一个bin/子目录和一个lib/python3.10子目录。

在第 7 步中，我们在~/venv-odoo-17.0目录中创建了一个新的虚拟环境。这将是我们 Odoo 的独立 Python 环境，Odoo 的所有 Python 依赖都将安装在这个环境中。

要激活虚拟环境，我们需要使用source命令。我们使用了source ~/venv-odoo-17.0/bin/activate命令来激活虚拟环境。

安装 Python 包

Odoo 的源代码在requirements.txt中有一个 Python 依赖列表。在第 8 步中，我们通过pip3 install命令安装了所有这些依赖项。

就这些了。现在，你可以运行 Odoo 实例。

启动实例

现在是你一直等待的时刻。为了启动我们的第一个实例，在第 9 步中，我们创建了一个新的空数据库，使用了odoo-bin脚本，然后使用以下命令启动了 Odoo 实例：

python3 odoo-bin -d odoo-test -i base --addons-path=addons --db-filter=odoo-test$

你也可以在odoo-bin之前使用./来省略python3，因为它是可执行的 Python 脚本：

./odoo-bin -d odoo-test -i base --addons-path=addons --db-filter=odoo-test$

使用odoo-bin，使用以下命令行参数的脚本：

-d database_name: 默认使用此数据库。
--db-filter=database_name$: 只尝试连接与提供的正则表达式匹配的数据库。一个 Odoo 安装可以服务于多个实例，这些实例位于不同的数据库中，此参数限制了可用的数据库。尾随的$很重要，因为正则表达式用于匹配模式。这使你能够避免选择以指定字符串开头的名称。
--addons-path=directory1,directory2,...: 这是一个逗号分隔的目录列表，Odoo 将在此目录中查找附加组件。在实例创建时扫描此列表以填充实例中可用的附加模块列表。如果你想使用 Odoo 的企业版，则可以使用此选项添加其目录。
-i base: 这用于安装基本模块。当你通过命令行创建数据库时，这是必需的。

如果你使用的是与 Linux 登录不同的数据库用户，你需要传递以下附加参数：

--db_host=localhost: 使用数据库服务器的 TCP 连接
--db_user=database_username: 使用指定的数据库登录
--db_password=database_password: 这是用于验证 PostgreSQL 服务器的密码

要获取所有可用选项的概述，请使用--help参数。我们将在本章后面看到更多关于odoo-bin脚本的内容。

当 Odoo 在一个空数据库上启动时，它将创建支持其操作所需的数据库结构。它还会扫描附加路径以查找可用的附加模块，并将一些模块插入到数据库中的初始记录中。这包括具有默认admin密码的admin用户，您将使用它进行身份验证。

将您的网络浏览器指向http://localhost:8069/将带您到您新创建实例的登录页面，如下截图所示：

图 1.2 – Odoo 实例的登录屏幕

这是因为 Odoo 包含一个 HTTP 服务器。默认情况下，它监听 TCP 端口8069上的所有本地网络接口。

管理 Odoo 服务器数据库

当使用 Odoo 时，您实例中的所有数据都存储在 PostgreSQL 数据库中。所有您熟悉的标准化数据库管理工具都可用，但 Odoo 还提供了一些常见操作的 Web 界面。

准备中

我们假设您的工作环境已经设置好，并且您有一个正在运行的实例。

如何操作...

Odoo 数据库管理界面提供了创建、复制、删除、备份和恢复数据库的工具。还有更改主密码的方法，该密码用于保护对数据库管理界面的访问。

访问数据库管理界面

要访问数据库，请执行以下步骤：

前往您实例的登录屏幕（如果您已认证，请注销）。
点击管理数据库。这将带您导航到localhost:8069/web/database/manager（您也可以直接将浏览器指向该 URL）：

图 1.3 – 数据库管理器

设置或更改主密码

如果您使用默认值设置了实例并且尚未对其进行修改，正如我们将在下一节中解释的，数据库管理屏幕将显示一个警告，告诉您master password实例尚未设置，并建议您通过直接链接设置一个：

图 1.4 – 主密码警告

要设置主密码，请执行以下步骤：

点击设置主密码按钮。您将得到一个对话框，要求您填写新主密码字段：

图 1.5 – 设置新的主密码

输入一个复杂的新的密码，然后点击继续。

如果主密码已经设置，请点击屏幕底部的设置主密码按钮来更改它。在打开的对话框中，输入旧的主密码和新密码，然后点击继续：

图 1.6 – 修改主密码

注意

主密码是服务器配置文件中的admin_passwd键。如果服务器在没有指定配置文件的情况下启动，将在~/.odoorc中生成一个新的配置文件。有关配置文件的更多信息，请参考下一道菜谱。

创建新数据库

此对话框可用于创建由当前 Odoo 服务器处理的新数据库实例。按照以下步骤操作：

在数据库管理屏幕上，点击屏幕底部的创建数据库按钮。这将弹出一个以下对话框：

图 1.7 – 创建数据库对话框

按照以下方式填写表格：
- 主密码：这是此实例的主密码。
- 数据库名称：输入您希望创建的数据库名称。
- 电子邮件：在此处添加您的电子邮件地址；这将是您稍后的用户名。
- 密码：输入您想为新实例管理员用户设置的密码。
- 电话号码：设置您的电话号码（可选）。
- 语言：在下拉列表中选择您希望在新数据库中默认安装的语言。Odoo 将自动加载所选语言的翻译。
- 国家：在下拉列表中选择主要公司的国家。选择此选项将自动配置一些事情，包括公司的货币。
- 演示数据：勾选此框以获取演示数据。这对于运行交互式测试或为客户设置演示很有用，但不应用于设计用于包含生产数据的数据库。

注意

如果您希望使用数据库来运行模块的自动化测试（参考第七章，调试模块），您需要演示数据，因为 Odoo 中的绝大多数自动化测试都依赖于这些记录才能成功运行。

点击继续并等待新数据库初始化。之后，您将被重定向到实例，并以管理员身份连接。

故障排除

如果您被重定向到登录屏幕，这可能是由于filter选项。请注意，odoo-bin start命令会静默执行，只提供当前数据库。为了解决这个问题，只需像在从源安装 Odoo菜谱中所示的那样重新启动 Odoo 而不使用start命令。如果您有一个配置文件（请参阅本章后面的将实例配置存储在文件中菜谱），请检查db_filter选项是否未设置或设置为与新数据库名称匹配的值。

复制数据库

通常，您将有一个现有的数据库，并且您可能想对其进行实验以尝试一个程序或运行一个测试，但又不希望修改现有数据。这里的解决方案很简单：复制数据库并在副本上运行测试。根据需要重复此操作：

在数据库管理屏幕上，点击你想要克隆的数据库旁边的重复数据库链接：

图 1.8 – 重复数据库对话框

按照以下方式填写表格：
- 主密码：这是 Odoo 服务器的主密码
- 新名称：你想要给副本的名称
点击继续。
你可以点击数据库管理屏幕上新创建的数据库的名称，以访问该数据库的登录屏幕。

删除数据库

当你完成测试后，你将想要清理重复的数据库。为此，执行以下步骤：

在数据库管理屏幕上，你将在数据库名称旁边找到删除按钮。点击它将弹出以下对话框：

图 1.9 – 删除数据库对话框

填写表格，以及主密码字段，这是 Odoo 服务器的主密码。
点击删除。

警告！可能数据丢失！

如果你选择了错误的数据库并且没有备份，将无法恢复丢失的数据。

备份数据库

要创建备份，执行以下步骤：

在数据库管理屏幕上，你将在数据库名称旁边找到备份按钮。点击它将弹出以下对话框：

图 1.10 – 备份数据库对话框

按照以下方式填写表格：
- zip用于生产数据库，因为这是唯一的真实完整备份格式。只有在你不关心文件存储的情况下，才使用pg_dump格式进行开发数据库备份。
点击备份。备份文件将被下载到你的浏览器。

还原数据库备份

如果你需要恢复备份，你需要这样做：

在数据库管理屏幕上，你将在屏幕底部找到还原数据库按钮。点击它将弹出以下对话框：

图 1.11 – 还原数据库对话框

按照以下方式填写表格：
- 主密码：这是 Odoo 服务器的主密码。
- 文件：这是一个之前下载的 Odoo 备份。
- 数据库名称：提供要恢复备份的数据库的名称。该数据库必须在服务器上不存在。
- 此数据库可能已被移动或复制：如果原始数据库在另一台服务器上或已被从当前服务器删除，请选择此数据库已移动。否则，选择此数据库是副本，这是安全的默认选项。
点击继续。

注意

无法在数据库之上还原数据库。如果你尝试这样做，你会得到一个错误消息（数据库还原错误：数据库已存在）。你需要先删除数据库。

它是如何工作的...

除了更改主密码屏幕外，这些功能在服务器上运行 PostgreSQL 管理命令并通过 Web 界面返回报告。

主密码是仅存在于 Odoo 服务器配置文件中的一条非常重要的信息，永远不会存储在数据库中。曾经有一个默认值是admin，但使用此值是一个安全风险。在 Odoo v9 及以后的版本中，这被标识为未设置的主密码，并且当您访问数据库管理界面时，强烈建议您更改它。即使它存储在配置文件下的admin_passwd条目中，这也不等同于admin用户的密码；这两个密码是独立的。主密码是为 Odoo 服务器进程设置的，它可以处理多个数据库实例，每个实例都有一个独立的admin用户及其自己的密码。

安全考虑

记住，在本章中，我们考虑的是开发环境。当您在生产服务器上工作时，Odoo 数据库管理界面是需要被保护的东西，因为它可以访问大量敏感信息，尤其是如果服务器托管了多个不同客户的 Odoo 实例。

要创建一个新的数据库，Odoo 使用 PostgreSQL 的createdb工具，并调用内部 Odoo 函数以与您在空数据库上启动 Odoo 时相同的方式初始化新数据库。

要复制数据库，Odoo 使用createdb的--template选项，将原始数据库作为参数传递。这使用内部和优化的 PostgreSQL 例程在新数据库中复制模板数据库的结构，这比创建备份然后恢复要快得多（尤其是在使用需要您下载备份文件并再次上传的 Web 界面时）。

备份和恢复操作分别使用pg_dump和pg_restore工具。当使用zip格式时，备份还将包括一个文件存储的副本，其中包含当您配置 Odoo 使其不将这些文件保存在数据库中时的文档副本；这是 14.0 版本中的默认选项。除非您更改它，否则这些文件将驻留在~/.local/share/Odoo/filestore。

如果备份变得过大，下载它可能会失败。这可能是由于 Odoo 服务器本身无法在内存中处理大文件，或者因为服务器运行在反向代理后面，因为代理中设置了 HTTP 响应大小的限制。相反，由于相同的原因，您可能会在数据库恢复操作中遇到问题。当您开始遇到这些问题时，是时候投资一个更健壮的外部备份解决方案了。

还有更多...

经验丰富的 Odoo 开发者通常不使用数据库管理界面，而是从命令行执行操作。例如，要使用演示数据初始化新数据库，可以使用以下单行命令：

$ createdb testdb && odoo-bin -d testdb

使用此命令行的优点是，您可以在使用它时请求安装附加组件 – 例如，-i sale,purchase,stock。

要复制数据库，停止服务器并运行以下命令：

$ createdb -T dbname newdbname
$ cd ~/.local/share/Odoo/filestore # adapt if you have changed the data_dir
$ cp -r dbname newdbname
$ cd -

注意，在开发环境中，通常省略文件存储。

注意

使用createdb -T仅在数据库上没有活动会话时才有效，这意味着在从命令行复制数据库之前，您必须关闭您的 Odoo 服务器。

要删除实例，请运行以下命令：

$ dropdb dbname
$ rm -rf ~/.local/share/Odoo/filestore/dbname

要创建备份（假设 PostgreSQL 服务器在本地运行），请使用以下命令：

$ pg_dump -Fc -f dbname.dump dbname
$ tar cjf dbname.tgz dbname.dump ~/.local/share/Odoo/filestore/dbname

要恢复备份，请运行以下命令：

$ tar xf dbname.tgz
$ pg_restore -C -d dbname dbname.dump

警告！

如果您的 Odoo 实例使用不同的用户连接到数据库，您需要传递-U username以确保正确的用户是恢复的数据库的所有者。

将实例配置存储在文件中

odoo-bin脚本有数十个选项，记住它们所有以及如何在启动服务器时正确设置它们是很繁琐的。幸运的是，可以将它们全部存储在配置文件中，并且只需指定您想要在开发中更改的选项。

如何完成...

对于此配方，请执行以下步骤：

要为您的 Odoo 实例生成配置文件，请运行以下命令：
```
$ ./odoo-bin --save --config myodoo.cfg --stop-after-init
```
您可以添加额外的选项，它们的值将保存在生成的文件中。所有未设置选项都将使用默认值保存。要获取可能的选项列表，请使用以下命令：
```
--without-demo will become without_demo. This works for most options, but there are a few exceptions, all of which are listed in the following section.
```
编辑myodoo.cfg文件（使用以下章节中的表格来更改您可能想要更改的一些参数）。然后，要使用保存的选项启动服务器，请运行以下命令：
```
$ ./odoo-bin -c myodoo.cfg
```

注意

--config选项通常缩写为-c。

它是如何工作的...

启动时，Odoo 通过三次遍历加载其配置。首先，从源代码初始化所有选项的默认值集。然后解析配置，然后任何在文件中定义的值将覆盖默认值。最后，分析命令行选项，它们的值将覆盖之前遍历中获得的配置。

如我们之前提到的，可以通过查看命令行选项的名称来找到配置变量的名称，方法是去除前导破折号并将中间破折号转换为下划线。这里有几个例外，特别是以下这些：

表 1.1 – Odoo 参数在命令行和配置文件中的差异

这里是一个通常通过配置文件设置的选项列表：

表 1.2 – Odoo 参数及其用法

这里是一个与数据库相关的配置选项列表：

表 1.3 – Odoo 参数及其用法

Odoo 使用 Python 的 ConfigParser 模块解析配置文件。然而，Odoo 11.0 中的实现已经改变，不再可能使用变量插值。所以，如果你习惯于使用 %(section.variable)s 语法从其他变量的值定义变量的值，你需要改变你的习惯，并回到显式值。

一些选项在配置文件中未使用，但在开发过程中广泛使用：

表 1.4 – Odoo 参数及其用法

激活 Odoo 开发者工具

当作为开发者使用 Odoo 时，你需要知道如何在网页界面中激活开发者模式，以便你可以访问技术设置菜单和开发者信息。启用调试模式将暴露几个高级配置选项和字段。这些选项和字段在 Odoo 中被隐藏，以提供更好的可用性，因为它们不是每天都会使用。

如何做到这一点...

在网页界面中激活开发者模式，请执行以下步骤：

连接到你的实例并以 admin 身份进行认证。
前往设置菜单。
滚动到页面底部并找到开发者工具部分：

图 1.12 – 激活不同开发者模式的链接

点击激活 开发者模式。
等待用户界面重新加载。

替代方法

也可以通过编辑 URL 来激活开发者模式。在 # 符号之前插入 ?debug=1。例如，如果你的当前 URL 是 http://localhost:8069/web#menu_id=102&action=94 并且你想启用开发者模式，那么你需要将那个 URL 更改为 http://localhost:8069/web?debug=1#menu_id=102&action=94。此外，如果你想要使用带有资源的调试模式，那么将 URL 更改为 http://localhost:8069/web?debug=assets#menu_id=102&action=94。

要退出开发者模式，你可以执行以下任何一个操作：

编辑 URL 并在查询字符串中写入 ?debug=0。
从设置菜单中的相同位置使用停用开发者模式。
在顶部菜单中点击虫子图标，然后点击离开开发者工具选项。

许多开发者都在使用浏览器扩展来切换调试模式。通过这样做，你可以快速切换调试模式，而无需访问设置菜单。这些扩展适用于 Firefox 和 Chrome。以下截图显示了你可以使用并从 Chrome 商店找到的一个插件：

图 1.13 – 调试模式的浏览器扩展

注意

自 Odoo v13 以来，调试模式的行为已发生变化。从 v13 开始，调试模式的状态存储在会话中，这意味着即使你从 URL 中移除了?debug，调试模式仍然会保持激活状态。

它是如何工作的...

在开发模式下，会发生两件事：

当你在表单视图中的一个字段上或列表视图中的一个列上悬停时，你会得到工具提示。这些提供了有关字段的技术信息（内部名称、类型等）。
在右上角用户菜单旁边显示一个带有虫子图标的下拉菜单，让你可以访问显示的模型的技术信息、各种相关视图定义、工作流程、自定义过滤器管理等等。

存在一种名为开发模式（带资产）的开发模式变体。这种模式的行为类似于正常的开发模式，但发送到浏览器的 JavaScript 和 CSS 代码没有被压缩，这意味着你可以轻松地使用浏览器中的 Web 开发工具来调试 JavaScript 代码（更多内容请参阅第十五章，Web 客户端开发）。

谨慎！

在开发模式下和不带开发模式的情况下测试你的附加组件，因为 JavaScript 库的非压缩版本可能会隐藏只有在你压缩版本中才会出现的错误。

更新附加模块列表

当添加新的附加模块时，你需要运行更新模块列表向导，以便将你的新应用程序添加到应用程序列表中。在这个配方中，你将学习如何更新应用程序列表。

准备工作

使用你的管理员账户启动你的实例并连接到它。完成此操作后，激活开发模式（如果你不知道如何激活开发模式，请参阅激活 Odoo 开发 工具配方）。

如何操作…

要更新你的实例中可用的附加模块列表，你需要执行以下步骤：

打开应用程序菜单。
点击更新 应用程序列表：

图 1.14 – 更新应用程序列表

在出现的对话框中，点击更新：

图 1.15 – 更新应用程序列表的对话框

更新完成后，你可以点击应用程序条目来查看可用的附加模块的更新列表。你需要在搜索框中移除应用程序上的默认过滤器才能看到所有这些。

它是如何工作的…

当 Odoo 读取存储在附加模块目录中的__manifest__.py时。它期望找到一个 Python 字典。除非清单中包含一个设置为False的installable键，否则附加模块元数据将被记录在数据库中。如果模块已经存在，信息将被更新。如果没有，将创建一个新的记录。如果之前可用的附加模块未找到，则记录不会被从列表中删除。

注意

只有在你初始化数据库后添加新的附加路径时，才需要更新应用程序列表。如果你在初始化数据库之前将新的附加路径添加到配置文件中，那么就无需手动更新模块列表。

总结到目前为止我们所学的，安装完成后，你可以通过以下命令行启动 Odoo 服务器（如果你使用的是虚拟环境，那么你首先需要激活它）：

python3 odoo-bin -d odoo-test -i base --addons-path=addons --db-filter=odoo-test

一旦运行了模块，你就可以通过 http://localhost:8069 访问 Odoo。

你也可以使用配置文件来运行 Odoo，如下所示：

./odoo-bin -c myodoo.cfg

一旦启动了 Odoo 服务器，你就可以从应用菜单中安装/更新模块。

第二章：管理 Odoo 服务器实例

在第一章中，安装 Odoo 开发环境，我们探讨了如何仅使用源代码中提供的标准核心附加模块来设置 Odoo 实例。作为自定义 Odoo 默认功能的常规做法，我们创建一个单独的模块并将其保存在不同的存储库中，以便您可以稍后升级 Odoo 默认功能和您的存储库以保持其整洁。本章重点介绍向 Odoo 实例添加非核心或自定义附加模块。在 Odoo 中，您可以从多个目录加载附加模块。此外，建议您从单独的文件夹中加载第三方附加模块或您自己的自定义附加模块，以避免与 Odoo 核心模块冲突。即使是 Odoo 企业版也是一个附加模块目录，您需要像正常附加模块目录一样加载它。

在本章中，我们将涵盖以下食谱：

配置附加模块路径
标准化实例目录布局
安装和升级本地附加模块
从 GitHub 安装附加模块
应用附加模块的更改
应用和尝试提出的拉取请求（PRs）

关于术语

在本书中，我们将使用模块一词互换。所有这些都指的是可以从用户界面安装到 Odoo 的应用程序或扩展应用程序。

配置附加模块路径

通过addons_path参数的帮助，您可以将自己的附加模块加载到 Odoo 中。当 Odoo 初始化一个新的数据库时，它将在addons_path配置参数中提供的目录内搜索附加模块。Odoo 将在这些目录中搜索潜在的附加模块。

在addons_path中列出的目录应包含子目录，每个子目录都是一个附加模块。在数据库初始化之后，您将能够安装这些目录中给出的模块。

准备工作

本食谱假设您已经准备好一个实例，并生成了一个配置文件，如第一章中“将实例配置存储在文件中”食谱所述，安装 Odoo 开发环境。请注意，Odoo 的源代码位于~/odoo-dev/odoo，配置文件位于~/odoo-dev/odoo/myodoo.cfg。

如何操作…

要将~/odoo-dev/local-addons目录添加到实例的addons_path参数中，请执行以下步骤：

编辑您实例的配置文件；即~/odoo-dev/myodoo.cfg。
定位以addons_path=开头的行。默认情况下，它应该看起来像以下这样：
```
addons_path = ~/odoo-dev/odoo/odoo/addons,~/odoo-dev/odoo/addons
```
通过在后面添加逗号，然后是您想要添加到addons_path中的目录名称，来修改该行，如下面的代码所示：
```
addons_path = ~odoo-dev/odoo/odoo/addons,~odoo-dev/odoo/addons,~/odoo-dev/local-addons
```

从终端重启您的实例：

$ ~/odoo-dev/odoo/odoo-bin -c myodoo.cfg

它是如何工作的…

当 Odoo 重新启动时，会读取配置文件。期望addons_path变量的值是一个逗号分隔的目录列表。接受相对路径，但它们相对于当前工作目录，因此在配置文件中应避免使用。

到目前为止，我们只在 Odoo 中列出了附加组件目录，但在~/odoo-dev/local-addons中没有任何附加组件模块。即使您将新的附加组件模块添加到此目录，Odoo 也不会在用户界面中显示此模块。为此，您需要执行额外操作，如前一章中“更新附加组件模块列表”食谱中所述。

注意

原因在于，当您初始化新数据库时，Odoo 会自动将您的自定义模块列在可用模块中，但如果您在数据库初始化后添加新模块，那么您就需要手动更新可用模块列表，如第一章，“安装 Odoo 开发环境”中“更新附加组件模块列表”食谱所示。

还有更多...

当您第一次调用odoo-bin脚本以初始化新数据库时，您可以使用逗号分隔的目录列表传递--addons-path命令行参数。这将初始化包含在提供的附加组件路径中找到的所有附加组件的可用模块列表。当您这样做时，您必须明确包含基本附加组件目录（odoo/odoo/addons）以及核心附加组件目录（odoo/addons）。与前面的食谱略有不同的是，本地附加组件不能为空；它们必须包含至少一个子目录，该子目录具有附加模块的最小结构。

在第三章，“创建 Odoo 附加组件模块”中，我们将探讨如何编写您自己的模块。在此期间，这里有一个快速技巧来生成 Odoo 会高兴的东西：

$ mkdir -p ~/odoo-dev/local-addons/dummy
$ touch ~/odoo-dev/local-addons/dummy/__init__.py
$ echo '{"name": "dummy", "installable": False}' > \
~/odoo-dev/local-addons/dummy/__manifest__.py

您可以使用--save选项来保存配置文件的路径：

$ odoo/odoo-bin -d odoo-test \
--addons-path="odoo/odoo/addons,odoo/addons,~/odoo-dev/local-addons" \
--save -c ~/odoo-dev/myodoo.cfg --stop-after-init

在这种情况下，使用相对路径是可以的，因为它们将在配置文件中转换为绝对路径。

注意

由于 Odoo 仅在从命令行设置路径时检查附加路径中的目录以查找附加组件，而不是在从配置文件加载路径时检查，因此虚拟模块不再必要。因此，您可以将其删除（或者保留，直到您确信您不需要创建新的配置文件）。

标准化实例目录布局

我们建议您的开发和生产环境都使用类似的目录布局。这种标准化将在您必须执行维护操作时非常有用，它还将使您日常工作更加轻松。

此食谱创建了一个目录结构，将具有相似生命周期或类似目的的文件分组到标准子目录中。

注意

此配方仅在你想要管理类似的结构化开发和生产环境时有用。如果你不希望这样做，你可以跳过此配方。

此外，没有必要遵循此配方中相同的文件夹结构。请随意更改此结构以适应你的需求。

我们生成一个干净的目录结构，具有清晰标记的目录和专用角色。我们使用不同的目录来存储以下内容：

由其他人维护的代码（在src/中）
本地特定代码
实例的文件存储

如何做到这一点…

要创建建议的实例布局，你需要执行以下步骤：

为每个实例创建一个目录：

$ mkdir ~/odoo-dev/projectname
virtualenv object in a subdirectory called env/:

$ python3 -m venv env

创建一些子目录，如下所示：

src/: This contains the clone of Odoo itself, as well as various third-party add-on projects (we have added Odoo source code to the next step in this recipe)

local/：这用于保存你的实例特定附加组件
bin/：这包括各种辅助可执行 shell 脚本
filestore/：这被用作文件存储
logs/（可选）：这用于存储服务器日志文件
克隆 Odoo 并安装需求（有关此操作的详细信息，请参阅第一章，安装 Odoo 开发环境）：
```
$ git clone -b 17.0 --single-branch --depth 1 https://github.com/odoo/odoo.git src/odoo
bin/odoo:
```
!/bin/sh ROOT=$(dirname $0)/..

PYTHON=$ROOT/env/bin/python3 ODOO=$ROOT/src/odoo/odoo-bin

$PYTHON $ODOO -c $ROOT/projectname.cfg "$@" exit $?
使脚本可执行：
```
$ chmod +x bin/odoo
```

创建一个空的虚拟本地模块：

$ mkdir -p local/dummy
$ touch local/dummy/  init  .py
$ echo '{"name": "dummy", "installable": False}' >\ local/dummy/  manifest  .py

为你的实例生成一个配置文件：

$ bin/odoo --stop-after-init --save \
--addons-path src/odoo/odoo/addons,src/odoo/addons,local \
.gitignore file, which is used to tell GitHub to exclude given directories so that Git will ignore these directories when you commit the code; for example, filestore/, env/, logs/, and src/:

dotfiles，但有例外：

!.gitignore

python 编译文件

*.py[co]

emacs 备份文件

未跟踪的子目录

/env/

/src/

/filestore/

/logs/

为此实例创建一个 Git 仓库，并将你添加到 Git 的文件：

$ git init
$ git add .
$ git commit -m "initial version of projectname"

它是如何工作的…

通过为每个项目使用一个 virtualenv 环境，我们确保项目的依赖项不会与其他项目的依赖项冲突，这些项目可能运行不同版本的 Odoo 或将使用需要不同 Python 依赖项版本的第三方附加模块。这以牺牲少量磁盘空间为代价。

以类似的方式，通过使用针对我们不同项目的单独克隆的 Odoo 和第三方附加模块，我们能够让每个项目独立发展，并且只在需要它们的实例上安装更新，从而降低引入回归的风险。

bin/odoo 脚本允许我们运行服务器而无需记住各种路径或激活 virtualenv 环境。这也为我们设置了配置文件。你可以在其中添加额外的脚本以帮助你在日常工作中。例如，你可以添加一个脚本来检出你需要运行实例的不同第三方项目。

关于配置文件，我们在这里只演示了设置的基本选项，但你可以显然设置更多，例如数据库名称、数据库过滤器或项目监听的端口。有关此主题的更多信息，请参阅第一章，安装 Odoo 开发环境。

最后，通过在 Git 仓库中管理所有这些，使得在不同的计算机上复制设置变得非常容易，并且可以在团队间共享开发。

加速技巧

为了方便项目创建，你可以创建一个包含空结构的模板仓库，并为每个新项目分叉该仓库。这将帮助你避免重复输入bin/odoo脚本、.gitignore文件以及任何其他需要的模板文件（如README.md、变更日志等）。

安装和升级本地附加模块

Odoo 的核心功能来自于其附加模块。Odoo 本身提供了丰富的附加模块，同时你也可以从应用商店下载附加模块，或者自己编写附加模块。

在本食谱中，我们将演示如何通过 Web 界面和命令行安装和升级附加模块。

使用命令行进行这些操作的主要好处包括能够同时操作多个附加模块，以及在安装或更新过程中清晰地查看服务器日志，这在开发模式或编写实例安装脚本时非常有用。

准备工作

确保您有一个正在运行的 Odoo 实例，其数据库已初始化，并且插件路径已正确设置。在本食谱中，我们将安装/升级几个插件模块。

如何操作...

安装或更新插件有两种可能的方法——您可以使用 Web 界面或命令行。

从 Web 界面

要使用 Web 界面在您的数据库中安装新的插件模块，请执行以下步骤：

使用管理员账户连接到实例并打开应用菜单：

图 2.1 – Odoo 应用列表

使用搜索框定位您想要安装的插件。以下是一些帮助您完成此任务的说明：
1. 激活未安装过滤器。
2. 如果您在寻找特定功能的插件而不是广泛功能的插件，请移除应用过滤器。
3. 在搜索框中输入模块名称的一部分，并将其用作模块过滤器。
4. 您可能会发现使用列表视图更易于阅读。
在卡片下模块名称下点击安装按钮。

注意，一些 Odoo 插件模块有外部 Python 依赖项。如果系统上未安装 Python 依赖项，则 Odoo 将中止安装，并显示以下对话框：

图 2.2 – 外部库依赖警告

要解决这个问题，只需在您的系统上安装相关的 Python 依赖项。

要更新数据库中预安装的模块，请执行以下步骤：

使用管理员账户连接到实例。
打开应用菜单。
点击应用：

图 2.3 – Odoo 应用列表

使用搜索框定位您想要安装的插件。以下是一些建议：
1. 激活crm并按Enter键搜索 CRM 应用。
2. 您可能会发现使用列表视图更易于阅读。
在卡片右上角的三点处点击，然后点击升级选项：

图 2.4 – 升级模块的下拉链接

激活开发者模式以查看模块的技术名称。如果您不知道如何激活开发者模式，请参阅第一章，安装 Odoo 开发环境：

图 2.5 – 应用程序的技术名称

激活开发者模式后，它将以红色显示模块的技术名称。如果您使用的是 Odoo 社区版，您将看到一些带有升级按钮的额外应用。这些应用是 Odoo 企业版应用，为了安装/使用它们，您需要购买许可证。

从命令行

在您的数据库中安装新插件，请执行以下步骤：

找到扩展的名称。这是包含__manifest__.py文件的目录名称，不包括前导路径。
停止实例。如果您正在处理生产数据库，请进行备份。

运行以下命令：

$ odoo/odoo-bin -c instance.cfg -d dbname -i addon1,addon2 \
--stop-after-init

如果在配置文件中已设置，则可以省略-d dbname。

重新启动实例。

要更新数据库中已安装的扩展模块，请执行以下步骤：

找到要更新的扩展模块名称；这是包含__manifest__.py文件的目录名称，不包括前导路径。
停止实例。如果您正在处理生产数据库，请进行备份。

运行以下命令：

$ odoo/odoo-bin -c instance.cfg -d dbname -u addon1 \
--stop-after-init

如果在配置文件中已设置，则可以省略-d dbname。

重新启动实例。

它是如何工作的…

扩展模块的安装和更新是两个密切相关的过程，但有一些重要区别，如下两个部分所强调的。

扩展安装

当您安装扩展时，Odoo 会检查其可用的扩展列表，以查找具有提供名称未安装的扩展。它还会检查该扩展的依赖项，如果有，它会在安装扩展之前递归地安装它们。

单个模块的安装过程包括以下步骤：

如果有任何依赖项，运行preinit扩展钩子。
从 Python 源代码加载模型定义，并根据需要更新数据库结构（有关详细信息，请参阅第四章，应用模型）。
加载扩展的数据文件，并根据需要更新数据库内容（有关详细信息，请参阅第六章，管理模块数据）。
如果在实例中启用了演示数据，则安装扩展的演示数据。
如果有任何依赖项，运行扩展的postinit钩子。
运行扩展视图定义的验证。
如果启用了演示数据和测试，则运行扩展的测试（有关详细信息，请参阅第十八章，自动化测试用例）。
更新数据库中的模块状态。
从扩展的翻译中更新数据库中的翻译（有关详细信息，请参阅第十一章，国际化）。

注意

preinit和postinit钩子分别使用pre_init_hook和post_init_hook键在__manifest__.py文件中定义。这些钩子用于在安装扩展模块之前和之后调用 Python 函数。要了解更多关于init钩子的信息，请参阅第三章，创建 Odoo 扩展模块。

扩展更新

当您更新扩展时，Odoo 会检查其可用的扩展模块列表，以查找具有给定名称已安装的扩展。它还会检查该扩展的逆向依赖项（这些是依赖于更新扩展的扩展）。如果有，它也会递归地更新它们。

单个附加组件模块的更新过程包括以下步骤：

如果有，运行附加组件模块的预迁移步骤（有关详细信息，请参阅第六章，管理模块数据）。
从 Python 源代码加载模型定义，并在必要时更新数据库结构（有关详细信息，请参阅第四章，应用模型）。
加载附加组件的数据文件，并在必要时更新数据库内容（有关详细信息，请参阅第六章，管理模块数据）。
如果实例中启用了演示数据，则更新附加组件的演示数据。
如果你的模块有任何迁移方法，运行附加组件的后期迁移步骤（有关详细信息，请参阅第六章，管理模块数据）。
运行附加组件视图定义的验证。
如果启用了演示数据和测试，则运行附加组件的测试（有关详细信息，请参阅第十八章，自动化测试用例）。
更新数据库中的模块状态。
从附加组件的翻译中更新数据库中的翻译（有关详细信息，请参阅第十一章，国际化）。

注意

注意，更新尚未安装的附加组件模块没有任何作用。然而，安装已安装的附加组件模块会重新安装该附加组件，这可能会对某些数据文件产生一些意外影响，这些数据文件包含应由用户更新但在正常模块更新过程中未更新的数据（请参阅第六章，管理模块数据中的使用 noupdate 和 forcecreate 标志配方）。用户界面没有错误风险，但这种情况可能会在命令行中发生。

从 GitHub 安装插件模块

GitHub 是第三方插件的绝佳来源。许多 Odoo 合作伙伴使用 GitHub 来共享他们内部维护的插件，Odoo 社区协会（OCA）在 GitHub 上共同维护了数百个插件。在你开始编写自己的插件之前，请确保检查是否已经存在你可以直接使用或作为起点的东西。

本食谱将向您展示如何从 GitHub 克隆 OCA 的partner-contact项目，并使其包含的插件模块在您的实例中可用。

准备工作

假设你想要向客户（合作伙伴）表单添加新字段。默认情况下，Odoo 客户模型没有gender字段。如果你想添加一个gender字段，你需要创建一个新的模块。幸运的是，邮件列表上的某个人告诉你关于partner_contact_gender插件模块的信息，该模块由 OCA 作为partner-contact项目的一部分维护。

本食谱中使用的路径反映了在标准化实例目录布局食谱中提出的布局。

如何操作...

要安装partner_contact_gender，请执行以下步骤：

进入你的项目目录：

17.0 branch of the partner-contact project in the src/ directory:

$ git clone --branch 17.0 \

实例.cfg 中的 add-ons_path 行应如下所示：

addons_path = ~/odoo-dev/my-odoo/src/odoo/odoo/addons, \
~/odoo-dev/my-odoo/src/odoo/addons, \
~/odoo-dev/my-odoo/src/partner-contact, \
~/odoo-dev/local-addons

安装partner_contact_gender插件（如果你不知道如何安装模块，请查看之前的食谱，安装和升级本地插件模块）。

它是如何工作的...

所有 OCA 代码存储库都将它们的插件包含在单独的子目录中，这与 Odoo 对插件路径中目录的期望是一致的。因此，只需在某个位置克隆存储库并将其添加到插件路径中就足够了。

应用更改以添加插件

大多数在 GitHub 上可用的附加模块都可能发生变化，并且不遵循 Odoo 对其稳定版本施加的规则。它们可能收到错误修复或增强，包括您提交的问题或功能请求，这些更改可能引入数据库模式更改或数据文件和视图的更新。本食谱解释了如何安装更新版本。

准备工作

假设您报告了partner_contact_gender的问题，并收到通知称该问题已在partner-contact项目的17.0分支的最新修订版中解决。在这种情况下，您可能希望使用这个最新版本更新您的实例。

如何操作…

要将 GitHub 上的源代码修改应用到您的附加模块，您需要执行以下步骤：

停止使用该附加模块的实例。
如果是生产实例，请备份（参考第一章中的管理 Odoo 服务器数据库食谱，安装 Odoo 开发环境）。

前往partner-contact克隆的目录：

$ cd ~/odoo-dev/my-odoo/src/partner-contact

为项目创建一个本地标签，以便在出现问题的情况下回滚到该版本：
```
$ git checkout 17.0
$ git tag 17.0-before-update-$(date --iso)
```

获取源代码的最新版本：

partner_address_street3 add-on in your databases (refer to the *Installing and upgrading local add-on* *modules* recipe).

重新启动实例。

它是如何工作的…

通常，附加模块的开发者偶尔会发布附加模块的最新版本。此更新通常包含错误修复和新功能。在这里，我们将获取附加模块的新版本并在我们的实例中更新它。

如果git pull --ff-only失败，您可以使用以下命令回滚到上一个版本：

$ git reset --hard 17.0-before-update-$(date --iso)

然后，您可以尝试不带--ff-only的git pull，这将导致合并，但这意味着您在附加模块上有本地更改。

参见

如果更新步骤失败，请参考第一章中的从源更新 Odoo食谱，安装 Odoo 开发环境，以获取恢复说明。请记住，始终在数据库生产副本上测试更新。

应用和尝试提议的 PR

在 GitHub 的世界里，PR 是由开发者提出的一个请求，以便项目的维护者可以包含一些新的开发成果。这样的 PR 可能包含错误修复或新功能。这些请求在合并到main分支之前会经过审查和测试。

本食谱解释了如何将 PR 应用到您的 Odoo 项目中以测试改进或错误修复。

准备工作

如前一个食谱中所述，假设您报告了partner_address_street3的问题，并收到通知称该问题已在项目的17.0分支的一个未合并的 PR 中解决。开发者要求您在 PR #123 中验证修复。您需要使用这个分支更新测试实例。

你不应该直接在生产数据库上尝试这样的分支，所以首先创建一个包含生产数据库副本的测试环境（请参阅第一章，安装 Odoo 开发环境)。

如何做到这一点…

要应用和尝试 GitHub PR 的附加模块，你需要执行以下步骤：

停止实例。

前往partner-contact被克隆的目录：

$ cd ~/odoo-dev/my-odoo/src/partner-contact

为项目创建一个本地标签，以便在事情出错时可以回滚到该版本：
```
$ git checkout 17.0
123:
```
在你的数据库中添加partner_contact_gender1附加模块并重启实例（如果你不知道如何更新模块，请参阅安装和升级本地附加模块配方）。
测试更新—尝试重现你的问题，或者尝试你想要的特性。

如果这不起作用，请在 GitHub 的 PR 页面上评论，解释你做了什么以及什么没有起作用，以便开发者可以更新 PR。

如果它有效，请在 PR 页面上说明；这是 PR 验证过程的重要组成部分，并将加快main分支的合并。

它是如何工作的…

我们正在使用一个 GitHub 功能，该功能允许使用pull/nnnn/head分支名称通过数字拉取 PR，其中nnnn是 PR 的编号。git pull命令将合并远程分支到我们的分支中，在我们的代码库中应用更改。之后，我们更新附加模块，测试它，并向更改的作者报告任何失败或成功。

第三章：创建 Odoo 附加模块

现在我们已经拥有了开发环境，并且知道如何管理 Odoo 服务器实例和数据库，我们将学习如何创建 Odoo 附加模块。

本章的主要目标是理解附加模块的结构以及向其中添加组件的典型增量工作流程。本章食谱名称中提到的各种组件将在后续章节中详细介绍。

Odoo 模块可以包含多个元素：

业务对象：
- 声明为 Python 类，这些资源根据其配置自动由 Odoo 持久化
对象视图：
- 业务对象 UI 显示的定义
数据文件（声明模型元数据的 XML 或 CSV 文件）：
- 视图或报告
- 配置数据（模块参数化和安全规则）
- 示例数据和更多内容
Web 控制器：
- 处理来自网络浏览器、静态网络数据图像、或由 Web 界面或网站使用的 CSS 或 JavaScript 文件的请求

本章中，我们将涵盖以下食谱：

创建和安装新的附加模块
完成附加模块清单
组织附加模块的文件结构
添加模型
添加菜单项和视图
添加访问安全
使用scaffold命令创建模块

技术要求

对于本章，你应已安装 Odoo，并且应已遵循第一章，安装 Odoo 开发环境中的食谱。你还应熟悉发现和安装额外附加模块，如第二章，管理 Odoo 服务器实例中所述。

本章中使用的所有代码都可以从 GitHub 仓库github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter03下载。

什么是 Odoo 附加模块？

除了框架代码外，Odoo 的所有代码库都以模块的形式打包。这些模块可以从数据库中随时安装或卸载。这些模块有两个主要目的。你可以添加新的应用程序/业务逻辑，或者你可以修改现有的应用程序。简单来说，在 Odoo 中，一切从模块开始，到模块结束。

Odoo 提供各种业务解决方案，如销售、采购、POS、会计、制造、项目和库存。创建新模块涉及向业务添加新功能或升级现有功能。

Odoo 的最新版本在社区和商业版中都引入了众多新模块。这些包括会议室、待办事项以及几个与 WhatsApp 相关的集成模块。

此外，这个版本还包含了许多令人兴奋的新功能，如重新设计的用户界面、改进的搜索功能以及 CRM、制造和电子商务的新功能。新版本还包括其他一些改进，如增强的性能、改进的安全性和更多集成。

Odoo 被各种规模的公司使用；每个公司都有不同的业务流程和需求。为了处理这个问题，Odoo 将应用程序的功能划分为不同的模块。这些模块可以根据需要加载到数据库中。基本上，管理员可以在任何时候启用/禁用这些功能。因此，相同的软件可以根据不同的需求进行调整。查看以下 Odoo 模块的截图；列中的第一个模块是主应用程序，其他模块旨在为该应用程序添加额外功能。要按应用程序的类别分组获取模块列表，请转到应用菜单并按类别分组：

图 3.1 – 按类别分组应用程序

如果您计划在 Odoo 中开发新的应用程序，您应该为各种功能创建边界。这将非常有帮助，可以将您的应用程序划分为不同的附加模块。现在您已经知道了 Odoo 中附加模块的目的，我们可以开始构建自己的模块。

创建和安装新的附加模块

在这个食谱中，我们将创建一个新的模块，使其在我们的 Odoo 实例中可用，并安装它。

准备工作

首先，我们需要一个准备就绪的 Odoo 实例。

如果您遵循了第一章中“从源代码轻松安装 Odoo”食谱的安装 Odoo 开发环境，Odoo 应该位于~/odoo-dev/odoo。为了解释的目的，我们将假设这个位置是 Odoo，尽管您可以使用任何其他您偏好的位置。

我们还需要一个位置来添加我们自己的 Odoo 模块。为了本食谱的目的，我们将在odoo目录旁边使用local-addons目录，位于~/odoo-dev/local-addons。

您可以在 GitHub 上上传自己的 Odoo 模块，并在本地系统上克隆它们以进行开发。

如何操作...

作为示例，我们将为这一章创建一个小型附加模块来管理宿舍。

以下步骤将创建并安装一个新的附加模块：

更改我们将工作的工作目录，并创建放置自定义模块的附加目录：
```
$ cd ~/odoo-dev
my_hostel:
```
init.py 文件：
```
my_hostel folder, create an __manifest__.py file with this line:
```
{'name': 'Hostel Management'}

在附加路径中启动您的 Odoo 实例，包括模块目录：

--save option is added to the Odoo command, the add-ons path will be saved in the configuration file. The next time you start the server, if no add-on path option is provided, this will be used.

在您的 Odoo 实例中启用新模块。使用admin登录 Odoo，在关于框中启用开发者模式，然后在应用顶部菜单中选择更新应用列表。现在，Odoo 应该知道我们的 Odoo 模块：

图 3.2 – 更新应用列表的对话框

选择my_hostel。点击激活按钮，安装将完成。

它是如何工作的...

Odoo 模块是一个包含代码文件和其他资产的目录。所使用的目录名是该模块的技术名称。模块清单中的name键是其标题。

__manifest__.py文件是模块清单。它包含一个包含模块元数据的 Python 字典，包括类别、版本、它所依赖的模块以及它将加载的数据文件列表。它包含有关附加模块的重要元数据并声明应加载的数据文件。

在这个食谱中，我们使用了最小的清单文件，但在实际模块中，我们需要其他重要的键。这些将在下一个食谱完成附加模块清单中讨论。

模块目录必须是 Python 可导入的，因此它还需要有一个__init__.py文件，即使它是空的。要加载一个模块，Odoo 服务器将导入它。这将导致__init__.py文件中的代码被执行，因此它作为运行模块 Python 代码的入口点。因此，它通常包含导入语句来加载模块 Python 文件和子模块。

已知的模块可以直接从命令行使用--init或my_hostel应用程序安装，你可以使用my_hostel。此列表是在你从当时提供的附加路径上找到的模块创建新数据库时设置的。它可以通过更新模块 列表菜单在现有数据库中更新。

完成附加模块清单

清单是 Odoo 模块的一个重要组成部分。

准备工作

我们应该有一个模块来工作，它已经包含一个__manifest__.py清单文件。你可能想遵循前面的食谱来提供这样一个模块来工作。

如何做...

我们将在我们的附加模块中添加一个清单文件和一个图标：

要创建包含最相关键的清单文件，编辑模块的__manifest__.py文件，使其看起来像这样：

{
    'name': "Hostel Management",
    'summary': "Manage Hostel easily",
    'description': "Efficiently manage the entire residential facility in the school.", # Supports reStructuredText(RST) format (description is Deprecated),
    'author': "Your name",
    'website': "http://www.example.com",
    'category': 'Uncategorized',
    'version': '17.0.1.0.0',
    'depends': ['base'],
    'data': ['views/hostel.xml'],
    'assets': {
    'web.assets_backend': [
        'web/static/src/xml/**/*',
    ],
           },
     'demo': ['demo.xml'],
}

要为模块添加图标，选择一个 PNG 图像并复制到static/description/icon.png。

它是如何工作的...

清单文件中的内容是一个常规 Python 字典，具有键和值。我们使用的示例清单包含最相关的键：

name：这是模块的标题。
summary：这是带有单行描述的副标题。
description：这是一个以纯文本或ReStructuredText (RST)格式编写的长描述。它通常被三重引号包围，并在 Python 中用于界定多行文本。有关 RST 快速入门参考，请访问docutils.sourceforge.net/docs/user/rst/quickstart.html。
author：这是一个包含作者名称的字符串。当有多个作者时，通常使用逗号分隔他们的名字，但请注意，它仍然是一个字符串，而不是 Python 列表。
website：这是人们应该访问的 URL，以了解更多关于模块或作者的信息。
category：这是根据兴趣领域组织模块。可以在 github.com/odoo/odoo/blob/17.0/odoo/addons/base/data/ir_module_category_data.xml 中看到可用的标准类别名称列表。然而，也可以在这里定义其他新的类别名称。
version：这是模块的版本号。Odoo 应用商店可以使用它来检测已安装模块的新版本。如果版本号不以 Odoo 目标版本开头（例如，17.0），它将被自动添加。不过，如果您明确地声明 Odoo 目标版本会更具有信息量——例如，使用 17.0.1.0.0 或 17.0.1.0，而不是分别使用 1.0.0 或 1.0。
depends：这是一个包含它直接依赖的模块的技术名称列表。如果您的模块不依赖于任何其他附加模块，那么您至少应该添加一个 base 模块。不要忘记包括任何定义 XML IDs、视图或模型并在此模块中引用的模块。这将确保它们按正确顺序加载，避免难以调试的错误。
data：这是在模块安装或升级期间要加载的数据文件的相对路径列表。路径相对于模块 root 目录。通常，这些是 XML 和 CSV 文件，但也可能有 YAML 数据文件。这些在 第六章，管理模块数据 中进行了深入讨论。
demo：这是包含演示数据的文件的相对路径列表，用于加载。只有在数据库创建时启用了 Demo Data 标志的情况下，才会加载这些文件。

用作模块图标的图像是位于 static/description/icon.png 的 PNG 文件。

Odoo 预计在主要版本之间会有显著的变化，因此为某个主要版本构建的模块很可能在没有转换和迁移工作的情况下与下一个版本不兼容。因此，在安装模块之前，确保了解模块的 Odoo 目标版本非常重要。

为了确保兼容性，我们需要遵循以下步骤：

首先，检查安装是否成功。如果成功了，然后继续检查模块的功能是否正常工作。
然而，如果安装不成功，您将需要根据您收到的错误调整代码和功能逻辑。

还有更多...

在模块清单中，除了有长描述外，还可以有单独的描述文件。自 8.0 版本以来，它可以由一个 README 文件替换，该文件具有 .txt、.rst 或 .md（Markdown）扩展名。否则，在模块中包含一个 description/index.html 文件。

此 HTML 描述将覆盖在清单文件中定义的描述。

还有几个常用的键：

licence：默认值是LGPL-3。此标识符用于在模块中提供的许可证下。其他许可证可能性包括AGPL-3、Odoo Proprietary License v1.0（主要用于付费应用）和Other OSI Approved Licence。
application：如果这是True，则模块被列为应用程序。通常，这用于功能区域的中心模块。
auto_install：如果这是True，则表示这是一个粘合模块，当所有依赖项都安装时，它会自动安装。
installable：如果这是True（默认值），则表示该模块可供安装。
external_dependencies：一些 Odoo 模块内部使用Python/bin库。如果您的模块使用此类库，您需要将它们放在这里。这将阻止用户在主机机器上未安装列出的模块时安装模块。
{pre_init, post_init, uninstall}_hook：这是一个在安装/卸载期间调用的 Python 函数钩子。有关更详细的示例，请参阅第八章，高级服务器端开发技术。
Assets：定义了所有静态文件如何在各种资产包中加载。Odoo 资产按包分组。每个包（特定类型的文件路径列表 - xml、js、css或scss）在模块清单中列出。

有许多特殊键用于应用商店列表：

price：此键用于设置您的附加模块的价格。此键的值应该是一个整数值。如果没有设置价格，这意味着您的应用是免费的。
currency：这是价格所用的货币。可能的值是USD和EUR。此键的默认值是EUR。
live_test_url：如果您想为您的应用提供一个实时测试 URL，您可以使用此键在应用商店上显示“实时预览”按钮。
iap：如果模块用于提供 IAP 服务，请设置您的 IAP 开发者密钥。
images：这给出了图像的路径。这张图片将被用作 Odoo 应用商店的封面图片。

组织附加模块文件结构

附加模块包含代码文件和其他资产，如 XML 文件和图像。对于这些文件中的大多数，我们可以在模块目录内部自由选择放置位置。

然而，Odoo 在模块结构上使用了一些约定，因此建议遵循它们。适当的代码提高了可读性，简化了维护，有助于调试，降低了复杂性，并促进了可靠性。这些适用于每个新模块和所有新开发。

准备工作

我们期望有一个附加模块目录，其中只包含__init__.py和__manifest__.py文件。在这个菜谱中，我们假设这是local-addons/my_hostel。

如何操作...

要为附加模块创建基本骨架，请执行以下步骤：

为代码文件创建目录：

$ cd local-addons/my_hostel
$ mkdir models
$ touch models/__init__.py
$ mkdir controllers
$ touch controllers/__init__.py
$ mkdir views
$ touch views/views.xml
$ mkdir security
$ mkdir wizards
$ touch wizards/__init__.py
$ mkdir reports
$ mkdir data
$ mkdir demo
__init__.py file so that the code in the subdirectories is loaded:

从. import models导入

从controllers模块导入

从. import wizards导入

这应该会让我们开始一个包含最常用目录的结构，类似于这个：

my_hostel
├── __init__.py
├── __manifest__.py
├── controllers
│   └── __init__.py
├── data
├── demo
├── i18n
├── models
│   └── __init__.py
├── security
├── static
│   ├── description
│   └── src
│       ├─ js
│       ├─ scss
│       ├─ css
│       └ xml
├── reports
├── wizards
│   └── __init__.py
└──views
   └── __init__.py

它是如何工作的...

为了提供一些背景信息，一个 Odoo 扩展模块可以有三类文件：

Python 代码由__init__.py文件加载，其中.py文件和代码子目录被导入。包含 Python 代码的子目录，反过来，需要它们自己的__init__.py文件。
需要在__manifest__.py模块清单的data和demo键中声明的数据文件，以便加载，通常是用于用户界面的 XML 和 CSV 文件、固定数据以及演示数据。也可能有 YAML 文件，这些文件可以包含一些在模块加载时运行的程序性指令——例如，用于在 XML 文件中以编程方式生成或更新记录，而不是静态地。
Web 资源，例如 JavaScript 代码和库、CSS、SASS 以及 QWeb/HTML 模板，是用于构建 UI 部分和管理这些 UI 元素中用户动作的文件。这些文件通过在assets键上的清单声明，包括新文件和现有文件，将这些资源添加到 Web 客户端、小部件或网站页面上。

扩展文件组织在以下目录中：

models/目录包含后端代码文件，从而创建模型及其业务逻辑。建议每个模型一个文件，文件名与模型同名——例如，hostel.py用于hostel.hostel模型。这些在第四章，应用模型中有详细说明。
views/目录包含用户界面的 XML 文件，包括动作、表单、列表等。与模型一样，建议每个模型一个文件。网站模板的文件名预期以_template后缀结尾。后端视图在第九章，后端视图中有所解释，网站视图在第十四章，CMS 网站开发中有所说明。
data/目录包含包含模块初始数据的其他数据文件。数据文件在第六章，管理模块数据中有所解释。
demo/目录包含带有演示数据的文件，这对于测试、培训或模块评估很有用。
i18n/是 Odoo 查找翻译.pot和.po文件的位置。有关更多详细信息，请参阅第十一章，国际化。这些文件不需要在清单文件中提及。
security/目录包含定义访问控制列表的数据文件，通常是一个ir.model.access.csv文件，以及可能的一个 XML 文件，用于定义行级安全的访问组和记录规则。更多关于这方面的信息，请参阅第十章，安全访问。
controllers/ 包含网站控制器和提供此类功能的模块的代码文件。网络控制器在 第十三章 网络服务器开发 中有介绍。
static/ 是所有网络资产预期放置的位置。与其他目录不同，此目录名称不仅仅是一个约定。此目录中的文件是公开的，并且可以在不登录用户的情况下访问。此目录主要包含 JavaScript、样式表和图像等文件。它们不需要在模块清单中提及，但必须在网络模板中引用。这在 第十四章 CMS 网站开发 中有详细讨论。
wizards/ 包含所有与向导相关的文件。在 Odoo 中，向导用于存储中间数据。我们可以在 第八章 高级服务器端开发技术 中了解更多关于向导的信息。
reports/：Odoo 提供了一个生成 PDF 文档的功能，例如销售订单和发票。此目录包含所有与 PDF 报告相关的文件。我们将在 第十二章 自动化、工作流程、电子邮件和打印 中了解更多关于 PDF 报告的信息。

当向模块添加新文件时，不要忘记在 __manifest__.py 文件（对于数据文件）或 __init__.py 文件（对于代码文件）中声明它们；否则，这些文件将被忽略且不会被加载。

添加模型

模型定义了我们的业务应用程序将使用的数据结构。这个食谱展示了如何向模块添加一个基本模型。模型决定了数据库的逻辑结构和数据如何存储、组织和管理。换句话说，模型是一个可以与其他表链接的信息表。模型通常代表一个业务概念，例如销售订单、联系人或产品。

模块包含各种元素，例如模型、视图、数据文件、网络控制器和静态网络数据。

要创建一个宿舍模块，我们需要开发一个代表宿舍的模型。

准备工作

我们应该有一个模块来工作。如果你遵循了本章的第一个食谱，创建和安装新的附加模块，你将有一个名为 my_hostel 的空模块。我们将用它来解释。

如何做到这一点...

要添加一个新的 模型，我们需要添加一个描述它的 Python 文件，然后升级附加模块（或者如果尚未完成，则安装它）。所使用的路径相对于我们的附加模块位置（例如，~/odoo-dev/local-addons/my_hostel/）：

在 models/hostel.py 模块中添加一个 Python 文件，以下代码：

from odoo import fields, models
class Hostel(models.Model):
    _name = 'hostel.hostel'
    _description = "Information about hostel"
    name = fields.Char(string="Hostel Name", required=True)
    hostel_code = fields.Char(string="Code", required=True)
    street = fields.Char('Street')
    street2 = fields.Char('Street2')
    state_id = fields.Many2one("res.country.state", string="State")

添加一个 Python 初始化文件，包含要由 models/__init__.py 模块加载的代码文件，以下代码：
```
from . import hostel
```
编辑模块的 Python 初始化文件，以便模块加载 models/ 目录：
```
from . import models
```
通过命令行或用户界面中的应用菜单升级 Odoo 模块。在升级模块时，如果你仔细查看服务器日志，你应该会看到以下行：
```
odoo.modules.registry: module my_hostel: creating or updating database table
```

之后，新的hostel.hostel模型应该在我们的 Odoo 实例中可用。有两种方法可以检查我们的模型是否已添加到数据库中。

首先，你可以在 Odoo 用户界面中检查它。激活开发者工具并在这里打开hostel.hostel模型菜单。

第二种方法是检查你的 PostgreSQL 数据库中的表条目。你可以在数据库中搜索hostel_hostel表。在以下代码示例中，我们使用了test-17.0作为我们的数据库。然而，你可以用以下命令替换你的数据库名称：

$ psql test-17.0
test-17.0# \d hostel_hostel;

它是如何工作的...

我们的第一步是创建一个 Python 文件，在其中创建我们的新模块。

Odoo 框架有自己的ORM框架，它提供了对 PostgreSQL 数据库的抽象。通过继承 Odoo Python Model类，我们可以创建自己的模型（表）。当定义一个新的模型时，它也会被添加到一个中央模型注册表中。这使得其他模块稍后对其进行修改变得更容易。

模型有一些以下划线为前缀的通用属性。其中最重要的是_name，它提供了一个在整个 Odoo 实例中使用的唯一内部标识符。ORM 框架将根据此属性生成数据库表。在我们的配方中，我们使用了_name = 'hostel.hostel'。基于此属性，ORM 框架将创建一个名为hostel_hostel的新表。请注意，ORM 框架将通过替换_来创建表名。_description提供了模型的非正式名称，我们使用了_name = 'hostel.hostel'和_description='Information about hostel'，并且_description='Information about hostel'只能以字母字符开头，我们不能以数字或特殊符号字符开头。

model字段被定义为类属性。我们首先定义了name字段，它是Char类型。对于模型来说，有这个字段很方便，因为默认情况下，当其他模型引用它时，它被用作记录描述。

我们还使用了一个关系字段的例子——state_id。这定义了Hostel和State之间的多对一关系。

关于模型还有很多要说的，它们将在第四章，应用模型中深入探讨。

接下来，我们必须让我们的模块知道这个新的 Python 文件。这是通过__init__.py文件来完成的。由于我们将代码放在了models/子目录中，我们需要上一个__init__文件来导入该目录，该目录应该反过来包含另一个__init__文件，导入那里的每个代码文件（在我们的情况下只有一个）。

通过升级模块激活 Odoo 模型的变化。Odoo 服务器将处理将model类转换为数据库结构变化。

虽然这里没有提供示例，但也可以将这些 Python 文件添加业务逻辑，无论是通过向模型的类中添加新方法，还是通过扩展现有方法，如create()或write()。这将在第五章，基本 服务器端开发中讨论。

添加访问安全

当添加新的数据模型时，您需要定义谁可以创建、读取、更新和删除记录。当创建全新的应用程序时，这可能涉及定义新的用户组。因此，如果用户没有这些访问权限，那么 Odoo 将不会显示您的菜单和视图。在前一个配方中，我们通过将admin用户转换为超级用户来访问我们的菜单。完成此配方后，您将能够直接作为admin用户访问Hostel模块的菜单和视图。

此配方基于前一个配方中的Hostel模型，并定义了一个新的用户安全组，以控制谁可以访问或修改Hostel的记录。

准备工作

实现了hostel.hostel模型的附加模块，在先前的配方中提供，在本配方中，我们将为它添加安全规则。所使用的路径相对于我们的附加模块位置（例如，~/odoo-dev/local-addons/my_hostel/）。

如何操作...

我们想要添加到这个配方中的安全规则如下：

每个人都将能够阅读宿舍记录。
一个名为宿舍管理员的新用户组将有权创建、读取、更新和删除宿舍记录。

要实现这一点，您需要执行以下步骤：

创建一个名为security/hostel_security.xml的文件，内容如下：

<?xml version="1.0" encoding="utf-8"?>
<odoo>
<record id="module_category_hostel" model="ir.module.category">
    <field name="name">Hostel Management</field>
    <field name="sequence">31</field>
</record>
<record id="group_hostel_manager" model="res.groups">
    <field name="name">Hostel Manager</field>
    <field name="category_id" ref="module_category_hostel"/>
    <field name="users" eval="[(4, ref('base.user_root')),(4, ref('base.user_admin'))]"/>
</record>
<record id="group_hostel_user" model="res.groups">
    <field name="name">Hostel User</field>
    <field name="category_id" ref="module_category_hostel"/>
</record>
</odoo>

添加一个名为security/ir.model.access.csv的文件，内容如下：

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_hostel_manager_id,access.hostel.manager,my_hostel.model_hostel_hostel,my_hostel.group_hostel_manager,1,1,1,1
access_hostel_user_id,access.hostel.user,my_hostel.model_hostel_hostel,my_hostel.group_hostel_user,1,0,0,0

将这两个文件添加到__manifest__.py的data条目中：

# ...
"data": [
    "security/hostel_security.xml",
    "security/ir.model.access.csv",
    "views/hostel.xml",
],
# ...

一旦您更新实例中的附加组件，新定义的安全规则将生效。

它是如何工作的...

我们提供了两个新的数据文件，我们将它们添加到附加模块的清单中，以便安装或更新模块时在数据库中加载它们：

security/hostel_security.xml文件通过创建一个res.groups记录来定义一个新的安全组。我们还通过使用其引用 ID，base.user_admin，赋予宿舍管理员对admin用户的权限，这样管理员用户将有权访问hostel.hostel模型。
ir.model.access.csv文件将模型上的权限与组关联。第一行有一个空的group_id:id列，这意味着该规则适用于所有人。最后一行将所有权限授予我们刚刚创建的组的成员。

清单文件数据部分的文件顺序很重要。创建安全组的文件必须在列出访问权限的文件之前加载，因为访问权限定义依赖于组的存在。由于视图可以是特定于安全组的，我们建议将组的定义文件放在列表中以确保安全。

添加菜单项和视图

一旦我们有了满足数据结构需求的数据模型，我们希望有一个用户界面，以便我们的用户可以与之交互。菜单和视图在结构化和增强用户体验方面发挥着至关重要的作用。从技术角度来看，菜单是动态的用户界面组件，它呈现一组结构化的选项或链接，通常允许用户访问应用程序中的各种功能、功能或内容区域。这个菜谱基于前一个菜谱中的 Hostel 模型，并添加了一个菜单项来显示用户界面，包括列表和表单视图。

准备工作

实现之前菜谱中提供的 hostel.hostel 模型的附加模块是必需的。我们将使用的路径相对于我们的附加模块位置（例如，~/odoo-dev/local-addons/my_hostel/）。

如何操作...

要添加一个视图，我们将添加一个包含其定义的 XML 文件到模块中。由于这是一个新模型，我们还必须添加一个菜单选项，以便用户能够访问它。

对于模型，XML 文件添加视图文件夹以创建视图、操作和菜单项。

注意以下步骤的顺序很重要，因为其中一些步骤使用了对前一步骤中定义的 ID 的引用：

创建 XML 文件以添加描述用户界面的数据记录，views/hostel.xml：

<?xml version="1.0" encoding="utf-8"?>
<odoo>
<!-- Data records go here -->
</odoo>

将新的数据文件添加到附加模块的清单文件 __manifest__.py 中，通过将其添加到 views/hostel.xml：

{
    "name": "Hostel Management",
    "summary": "Manage Hostel easily",
    "depends": ["base"],
    "data": ["views/hostel.xml"],
}

在 hostel.xml 文件中添加打开视图的操作：

<record id="action_hostel" model="ir.actions.act_window">
        <field name="name">Hostel</field>
        <field name="type">ir.actions.act_window</field>
        <field name="res_model">hostel.hostel</field>
        <field name="view_mode">tree,form</field>
        <field name="help" type="html">
            <p class="oe_view_nocontent_create">
                Create Hostel.
            </p>
        </field>
    </record>

将菜单项添加到 hostel.xml 文件中，使其对用户可见：

<menuitem id="hostel_main_menu" name="Hostel" sequence="1"/>
<menuitem id="hostel_type_menu" name="Hostel" parent="hostel_main_menu" action="my_hostel.action_hostel" groups="my_hostel.group_hostel_manager" sequence="1"/>

将自定义表单视图添加到 hostel.xml 文件中：

<record id="view_hostel_form_view" model="ir.ui.view">
        <field name="name">hostel.hostel.form.view</field>
        <field name="model">hostel.hostel</field>
        <field name="arch" type="xml">
            <form string="Hostel">
                <sheet>
                    <div class="oe_title">
                        <h3>
                            <table>
                                <tr>
                                    <td style="padding-
                                    right:10px;">
                                    <field name="name" 
                                    required="1" 
                                    placeholder="Name" />
                                  </td>
                                    <td style="padding-
                                    right:10px;">
                                    <field name="hostel_code" 
                                    placeholder="Code" />
                                        </td>
                                </tr>
                            </table>
                        </h3>
                    </div>
                    <group>
                        <group>
                            <label for="street" 
                            string="Address"/>
                            <div class="o_address_format">
                                <field name="street" 
                                placeholder="Street..." 
                                class="o_address_street"/>
                                <field name="street2" 
                                placeholder="Street 2..." 
                                class="o_address_street"/>
                            </div>
                        </group>
                    </group>
                </sheet>
            </form>
        </field>
    </record>

将自定义树（列表）视图添加到 hostel.xml 文件中：

<record id="view_hostel_tree_view" model="ir.ui.view">
        <field    name="name">hostel.hostel.tree.view</field>
        <field name="model">hostel.hostel</field>
        <field name="arch" type="xml">
            <tree>
                <field name="name"/>
                <field name="hostel_code"/>
            </tree>
        </field>
</record>

添加自定义的 hostel.xml 文件：

<record id="view_hostel_search_view" model="ir.ui.view">
    <field name="name">Hostel Search</field>
    <field name="model">hostel.hostel</field>
    <field name="arch" type="xml">
        <search>
            <field name="name"/>
            <field name="hostel_code"/>
        </search>
    </field>
</record>

当在 Odoo 中添加新模型时，用户默认没有任何访问权限。我们必须为新模型定义访问权限才能获得访问权限。在我们的例子中，我们没有定义任何访问权限，因此用户无法访问我们的新模型。没有访问权限，我们的菜单和视图也不会可见。幸运的是，有一个快捷方式！通过切换到超级用户模式，您可以在没有访问权限的情况下查看我们的应用程序的菜单。

以超级用户身份访问 Odoo

通过将admin用户转换为superuser类型，您可以绕过访问权限，因此可以在不提供默认访问权限的情况下访问菜单和视图。要将admin用户转换为超级用户，请激活开发者模式。完成此操作后，从开发者工具选项中，点击成为超级用户选项。

作为开发者偏好，尝试在不成为超级用户的情况下做所有事情；这将非常有助于深入学习 Odoo。通过成为超级用户，所有安全访问和记录规则检查都将被绕过。

以下截图已提供作为参考：

图 3.3 – 激活超级用户模式的选项

成为超级用户后，您的菜单将具有条纹背景，如下面的截图所示：

图 3.4 – 激活超级用户模式

如果您现在尝试升级模块，您应该能够看到一个新的菜单选项（您可能需要刷新您的网络浏览器）。点击宿舍菜单将打开宿舍模型的列表视图，如下面的截图所示：

图 3.5 – 访问宿舍的菜单

它是如何工作的...

在较低级别，用户界面由存储在特殊模型中的记录定义。前两个步骤创建了一个空的 XML 文件来定义要加载的记录，然后我们将它们添加到模块的数据文件列表中，以便安装。

数据文件可以放置在模块目录的任何位置，但惯例是在views/子目录内定义用户界面。通常，这些文件的名称基于模型的名称。在我们的例子中，我们为hostel.hostel模型创建了用户界面，因此我们创建了views/hostel.xml文件。

下一步是定义一个窗口操作，以在 Web 客户端的主区域显示用户界面。该操作由res_model定义的目标模型，并且name属性用于在用户打开操作时向用户显示标题。这些只是基本属性。窗口操作支持其他属性，提供了更多控制视图渲染方式的能力，例如显示哪些视图，对可用的记录添加过滤器，或设置默认值。这些内容在第九章，后端视图中详细讨论。

通常，数据记录使用<record>标签定义，我们在我们的例子中为ir.actions.act_window模型创建了一个记录。这将创建窗口操作。

同样，菜单项存储在ir.ui.menu模型中，我们可以使用<record>标签创建这些。然而，Odoo 中有一个名为<menuitem>的快捷标签，因此我们在我们的例子中使用了这个标签。

这些是菜单项的主要属性：

name：这是要显示的菜单项文本。
action：这是要执行的操作的标识符。我们使用上一步中创建的窗口操作的 ID。
sequence：用于设置同一级别菜单项的显示顺序。
parent：这是父菜单项的标识符。在我们的示例菜单项中没有父项，这意味着它将显示在菜单的顶部。
web_icon：此属性用于显示菜单的图标。此图标仅在 Odoo 企业版中显示。

在这个阶段，我们还没有在我们的模块中定义任何视图。然而，如果你在这个阶段升级你的模块，Odoo 将会自动动态创建它们。尽管如此，我们肯定希望控制我们的视图外观，所以接下来两个步骤将创建一个表单视图和一个树形视图。

这两个视图都是通过 ir.ui.view 模型上的记录定义的。我们使用的属性如下：

name：这是一个标识视图的标题。在 Odoo 的源代码中，你将在这里找到重复的 XML ID，但如果你愿意，你可以添加一个更易读的标题作为名称。
如果省略了 name 字段，Odoo 将使用模型名称和视图类型生成一个。这对于新模型的常规视图来说完全没问题。当你扩展视图时，建议有一个更明确的名称，因为这将在你在 Odoo 用户界面中查找特定视图时使你的生活更容易。
model：这是目标模型的内部标识符，如在其 _name 属性中定义的那样。
arch：这是视图架构，其中其结构实际上被定义。这是不同类型的视图彼此区分的地方。

表单视图通过顶部的 <form> 元素定义，其画布是一个两列网格。在表单内部，使用 <group> 元素垂直组合字段。两个组产生两个带有字段的列，这些字段是通过 <field> 元素添加的。字段使用默认的小部件根据其数据类型，但可以使用 widget 属性使用特定的小部件。

树形视图更简单；它们通过包含要显示的列的 <field> 元素的顶部 <tree> 元素定义。

最后，我们添加了一个 <search> 最高级标签，我们可以有 <field> 和 <filter> 元素。字段元素是可以从搜索视图中输入的额外字段，而过滤器元素是预定义的过滤器条件，可以通过点击激活。这些主题在第九章，“后端视图”中详细讨论。

使用 `scaffold` 命令创建模块

当创建一个新的 Odoo 模块时，有一些样板代码需要设置。为了帮助快速启动新模块，Odoo 提供了 scaffold 命令。

这个示例展示了如何使用 scaffold 命令创建一个新的模块，这将为目录放置文件框架。

准备工作

我们将在自定义模块目录中创建新的附加模块，因此我们需要安装 Odoo 并创建一个自定义模块的目录。我们将假设 Odoo 安装于~/odoo-dev/odoo，并且我们的自定义模块将被放置在~/odoo-dev/local-addons目录中。

如何操作...

我们将使用scaffold命令来创建样板代码。按照以下步骤使用scaffold命令创建新模块：

将工作目录更改为我们希望模块所在的位置。这可以是您选择的任何目录，但它需要位于附加路径内才有用。根据我们在上一个菜谱中使用的目录选择，这应该是以下内容：
```
scaffold command to create it. For our example, we will choose my_module:
```
__manifest__.py默认模块清单提供并更改相关值。您肯定至少想要更改名称键中的模块标题。

这就是生成的附加模块应该看起来像什么：

$ tree my_module
my_module/
├── __init__.py
├── __manifest__.py
├── controllers
│   ├── __init__.py
│   └── controllers.py
├── demo
│   └── demo.xml
├── models
│   ├── __init__.py
│   └── models.py
├── security
│   └── ir.model.access.csv
└── views
    ├── templates.xml
    └── views.xml
5 directories, 10 files

您现在应该编辑各种生成的文件，并将它们适应您新模块的目的。

它是如何工作的...

scaffold命令根据模板创建新模块的骨架。

默认情况下，新模块将在当前工作目录中创建，但我们可以提供一个特定的目录来创建模块，通过传递一个额外的参数来实现。

考虑以下示例：

$ ~/odoo-dev/odoo/odoo-bin scaffold my_module ~/odoo-dev/local-addons

使用了一个default模板，但还有一个用于网站主题编写的theme模板可用。要选择特定的模板，可以使用-t选项。我们还可以使用一个包含模板的目录的路径。

这意味着我们可以使用自己的模板与scaffold命令一起使用。内置模板可以在/odoo/cli/templates Odoo 子目录中找到。要使用自己的模板，我们可以使用以下类似命令：

$ ~/odoo-dev/odoo/odoo-bin scaffold -t path/to/template my_module

默认情况下，Odoo 在/odoo/cli/templates目录中有两个模板。一个是default模板，另一个是theme模板。然而，您可以创建自己的模板或使用-t选项，如前述命令所示。

第四章：应用模型

本章将指导您对现有扩展模块进行一些小的改进。您已经在 第三章，创建 Odoo 扩展模块 中注册了您的扩展模块。现在，您将更深入地探索模块的数据库方面。您将学习如何创建新的模型（数据库表），添加新的字段，并应用约束。您还将发现如何使用 Odoo 中的继承来修改现有模型。在本章中，您将使用上一章中创建的相同模块。

本章涵盖了以下主题：

定义模型表示和顺序
向模型添加数据字段
添加可配置精度的浮点字段
向模型添加货币字段
向模型添加关系字段
向模型添加层次结构
向模型添加约束验证
向模型添加计算字段
暴露存储在其他模型中的相关字段
使用引用字段添加动态关系
使用继承向模型添加功能
使用抽象模型实现可重用模型功能
使用继承复制模型定义

技术要求

在继续本章的示例之前，请确保您已安装并配置了我们在 第三章，创建 Odoo 扩展模块 中开发的模块。

定义模型表示和顺序

模型指的是数据库表的表示。模型定义了数据库表的结构和行为，包括字段、关系和多种方法。模型使用 Odoo 的 对象关系映射（ORM）系统在 Python 代码中定义。ORM 允许开发人员使用 Python 类和方法与数据库交互，而不是编写原始 SQL 查询。

模型属性是在创建新模型时将要定义的模型特征；否则，我们使用已存在的模型的属性。模型使用带下划线前缀的结构属性来定义其行为。

准备工作

my_hostel 实例应该已经包含一个名为 models/hostel.py 的 Python 文件，该文件定义了一个基本模型。我们将编辑它以添加新的类级别属性。

如何操作...

通过有效地利用这些属性，开发人员可以在 Odoo 中创建组织良好、可重用和可维护的代码，从而实现更高效和健壮的应用程序。以下是可以用于模型上的属性：

_name : name 属性是最重要的一个，因为它决定了内部全局标识符和数据库表名。模型名在模块命名空间内以点表示法表达。例如，name="hostel.hostel" 将在数据库中创建 hostel_hostel 表：
```
_name = 'hostel.hostel'
```
_table：如果启用了‘_auto’，我们可以定义模型使用的 SQL 表名：
```
_name = 'project.task.stage.personal'
_table = 'project_task_user_rel'
```
_description：为了给模型分配一个反映其目的和功能的描述性标题，请插入以下代码片段：
```
_description = 'Information about hostel'
```

注意

如果您没有为您的模型使用_description，Odoo 将在日志中显示警告。

_order：默认的搜索结果排序字段是'id'。但是，可以通过提供一个包含逗号分隔的字段名称列表的字符串的_order属性来更改它，以便我们可以使用我们选择的字段。字段名称后可以跟desc关键字以降序排序。要按id降序排序，然后按名称升序排序记录，请使用以下代码语法：
```
_order = "id desc, name"
```

注意

只能使用存储在数据库中的字段。无法使用非存储的计算字段对记录进行排序。_order字符串的语法类似于SQL ORDER BY子句，尽管它被简化了。例如，不允许使用特殊子句，如NULLS FIRST。

_rec_name：此属性用于设置用作记录表示或标题的字段。rec_name的默认字段是名称字段。_rec_name是 Odoo 的rec_name使用的记录显示名称，并将hostel_code设置为模型的代表，使用以下代码语法：
```
_rec_name = 'hostel_code'
hostel_code = fields.Char(string="Code", required=True)
```

注意

如果您的模型没有名称字段，并且您也没有指定_rec_name，则您的显示名称将是模型名称和记录 ID 的组合，如下所示 - (``hostel.hostel, 1)。

_rec_names_search：此属性用于通过提到的字段值搜索特定记录。它与使用name_search函数类似。您可以直接使用此属性而不是使用name_search方法。为此，请使用以下代码语法：
```
_rec_names_search = ['name', 'code']
```

向模型添加数据字段

字段代表数据库表中的一列，并定义了可以存储在该列中的数据结构。Odoo 模型中的字段用于指定模型将存储的数据的属性和特征。每个字段都有一个数据类型（例如，Char、Integer、Float或Date）以及确定字段行为的各种属性。

在本节中，您将探索字段可以支持的各种数据类型以及如何将它们添加到模型中。

准备工作

本食谱假设您已经有一个带有my_hostel附加模块的实例，如第三章，创建 Odoo 附加模块中所述。

如何操作...

my_hostel附加模块应该已经包含models/hostel.py，定义了一个基本模型。我们将编辑它以添加新字段：

使用最小语法向Hostel模型添加字段：

from odoo import models, fields
class Hostel(models.Model):
    # …
    email = fields.Char('Email')
    hostel_floors = fields.Integer(string="Total Floors")
    image = fields.Binary('Hostel Image')
    active = fields.Boolean("Active", default=True,
    help="Activate/Deactivate hostel record")
    type = fields.Selection([("male", "Boys"), ("female", "Girls"),
    ("common", "Common")], "Type", help="Type of Hostel",
    required=True, default="common")
    other_info = fields.Text("Other Information",
    help="Enter more information")
    description = fields.Html('Description')
    hostel_rating = fields.Float('Hostel Average Rating', digits=(14, 4))

我们已经向模型添加了新字段。我们还需要将这些字段添加到表单视图中，以便在用户界面中反映这些更改。请参考以下代码以向表单视图添加字段：

<field name="image" widget="image" class="oe_avatar"/>
  <group>
    <group>
    <label for="street" string="Address"/>
    <div class="o_address_format">
      <field name="street" placeholder="Street..." class="o_address_street"/>
      <field name="street2" placeholder="Street 2..." class="o_address_street"/>
      <field name="city" placeholder="City" class="o_address_city"/>
      <field name="state_id" class="o_address_state" 
      placeholder="State" options='{"no_open": True}'/>
      <field name="zip" placeholder="ZIP" class="o_address_zip"/>
      <field name="country_id" placeholder="Country"
      class="o_address_country" options='{"no_open": True,
       "no_create": True}'/>
    </div>
    <field name="phone" widget="phone"/>
    <field name="mobile" widget="phone"/>
    <field name="email" widget="email" context="{'gravatar_image': True}"/>
    </group>
    <group>
      <field name="hostel_floors"/>
      <field name="active"/>
      <field name="type"/>
      <field name="hostel_rating"/>
      <field name="other_info"/>
    </group>
  </group>
  <group>
    <field name="description"/>
  </group>

升级模块将使这些更改在 Odoo 模型中生效。

它是如何工作的...

要向模型添加字段，您需要在它们的 Python 类中定义相应类型的属性。非关系字段的可用类型如下：

字符：存储字符串值。
文本：存储多行字符串值。
选择：存储从预定义值和描述的列表中选择的一个值。它包含值和描述对的列表。所选的值将存储在数据库中，可以是字符串或整数。描述是自动可翻译的。

注意

如果整数字段的值为零，Odoo 不会显示描述。选择字段也接受函数引用作为其选择属性，而不是列表。这允许您动态生成选项列表。您可以在本章的使用引用字段添加动态关系食谱中找到一个相关示例，其中也使用了选择属性。

HTML：以 HTML 格式存储富文本。
二进制：存储二进制文件，如图像或文档。
True/False值。
使用fields.Date.today()将默认值设置为当前日期。
将datetime值作为 UTC 时间的 Python datetime 对象。使用fields.Date.now()将默认值设置为当前时间。
整数：存储整数值。
浮点数：存储具有可选精度的数值（总位数和小数位数）。
货币：以特定货币存储金额。这将在本章的 将货币字段添加到模型 菜谱中进一步解释。

步骤 1 显示了添加到每种字段类型的最小语法。字段定义可以扩展以添加其他可选属性，如 步骤 2 所示。以下是已使用字段属性的说明：

string 是字段的标题，并用于 UI 视图标签。它是可选的。如果没有设置，将根据字段名称推导标签，通过添加标题大小写并替换下划线为空格。
当设置为 True 时，translate 使得字段可翻译。它的值可能因用户界面语言而异。
default 是默认值。它也可以是一个用于计算默认值的函数——例如，default=_compute_default，其中 _compute_default 是在字段定义之前在模型上定义的方法。
help 是在 UI 工具提示中显示的解释文本。
groups 使得字段仅对某些安全组可用。它是一个包含以逗号分隔的安全组 XML ID 列表的字符串。这将在第十章 安全访问中更详细地说明。
copy 标志表示在记录复制时是否复制字段值。默认情况下，对于非关系和 Many2one 字段为 True，对于 One2many 和计算字段为 False。
当设置为 True 时，index 为字段创建数据库索引，这有时可以允许更快的搜索。它替换了已弃用的 select=1 属性。
readonly 标志使得字段在用户界面中默认为只读。
required 标志使得字段在用户界面中默认为必填项。
这里提到的各种白名单在 odoo/fields.py 中定义。
company_dependent 标志使得字段为每个公司存储不同的值。它替换了已弃用的 Property 字段类型。
值不存储在模型表上。它注册为 ir.property。当需要 company_dependent 字段的值时，将搜索 ir.property 并将其链接到当前公司（如果存在一个属性，则还包括当前记录）。如果记录上的值被更改，它将修改当前记录的现有属性（如果存在）或为当前公司和 res_id 创建一个新的属性。如果公司侧的值被更改，它将影响所有尚未更改值的记录。
group_operator 是一个聚合函数，用于在按组模式显示结果。

此属性的可能的值包括 count、count_distinct、array_agg、bool_and、bool_or、max、min、avg 和 sum。整数、浮点数和货币字段类型对此属性的默认值为 sum。此字段由 :meth:~odoo.models.Model.read_group 方法用于根据此字段分组行。

支持的聚合函数如下：
- array_agg：将所有值（包括空值）连接到一个数组中
- count：计算行数
- count_distinct：计算不同行数
- bool_and：如果所有值都是 true，则返回 true，否则返回 false
- bool_or：如果至少有一个值是 true，则返回 true，否则返回 false
- max：返回所有值的最大值
- min：返回所有值的最小值
- avg：返回所有值的平均值
- sum：返回所有值的总和
Store：用于确定字段是否存储在数据库中（默认为 True，对于计算字段为 False）。

group_expand：此函数用于在按当前字段分组时扩展 read_group 结果：

   .. code-block:: python
        @api.model
        def _read_group_selection_field(self, values, domain, order):
            return ['choice1', 'choice2', ...] # available selection choices.
         @api.model
        def _read_group_many2one_field(self, records, domain, order):
            return records + self.search([custom_domain])

在 HTML 字段中使用 sanitize 标志来系统地从其内容中移除可能不安全的标签。激活此标志会导致对输入进行彻底的清洁。对于寻求对 HTML 清洁有更细致控制的用户，还有其他一些属性可用。重要的是要注意，这些属性仅在启用 sanitize 标志时有效。

如果您需要在 HTML 清洁中实现更精细的控制，可以使用一些额外的属性，但这些属性仅在启用 sanitize 时有效：

sanitize_tags=True，用于移除不属于白名单的标签（这是默认设置）
sanitize_attributes=True，用于移除不属于白名单的标签属性
sanitize_style=True，用于移除不属于白名单的样式属性
strip_style=True，用于移除所有样式元素
strip_class=True，用于移除类属性

最后，我们根据模型中新添加的字段更新了表单视图。我们将所有字段放置在表单视图中，但您可以将它们放置在任何您想要的位置。表单视图在第九章，后端视图中有更详细的解释。

还有更多...

Date 和 Datetime 字段对象公开了一些实用方法，这些方法对于日期和 datetime 非常方便：

对于 Date，我们有以下内容：

fields.Date.to_date(string_value) 将字符串解析为日期对象。
fields.Date.to_string(date_value) 将 Python 日期对象转换为字符串。
fields.Date.today() 以字符串格式返回当前日期。这适用于使用默认值。
fields.Date.context_today(record, timestamp) 以字符串格式返回时间戳的日期（如果省略时间戳，则为当前日期），根据记录（或记录集）的上下文时区。

对于 Datetime，我们有以下内容：

fields.Datetime.to_datetime(string_value) 将字符串解析为 datetime 对象。
fields.Datetime.to_string(datetime_value) 将 datetime 对象转换为字符串。
fields.Datetime.now() 以字符串格式返回当前日期和时间。这适用于使用默认值。
fields.Datetime.context_timestamp(record, timestamp) 将一个无时区信息的 datetime 对象转换为具有时区信息的 datetime 对象。使用记录上下文中的时区。这不适合作为默认值，但可以在向外部系统发送数据时使用。

除了基本字段外，还有一些关系字段，如 Many2one、One2many 和 Many2many。这些内容在本章的 向模型添加关系字段 菜谱中有详细说明。

你也可以通过使用 compute 字段属性来定义计算函数，从而创建具有自动计算值的字段。这在本章的 向模型添加计算字段 菜谱中有详细说明。

Odoo 模型中默认添加了一些字段，因此你应该避免使用这些名称作为你的字段名称。具体如下：

id（记录自动生成的标识符）
create_date（记录创建的时间戳）
create_uid（创建记录的用户）
write_date（最后记录的时间戳编辑）
write_uid（最后编辑记录的用户）

可以通过设置 _log_access=False 模型属性来禁用这些日志字段的自动创建。

可以添加到模型中的另一个特殊列是 active。它必须是一个 Boolean 字段，允许用户将记录标记为非活动状态。它用于在记录上启用 archive/unarchive 功能。其定义如下：

active = fields.Boolean('Active', default=True)

默认情况下，只有将 active 设置为 True 的记录是可见的。要检索它们，我们需要使用 [('active', '=', False)] 域过滤器。或者，如果将 'active_test': False 值添加到环境上下文中，ORM 不会过滤掉非活动记录。

在某些情况下，你可能无法修改上下文以获取活动和非活动记录。如果是这样，你可以使用 ['|', ('active', '=', True), ('active', '=', False)] 域。

小贴士

[('active', 'in' (True, False))] 并不会像你预期的那样工作。Odoo 明确在域中寻找 ('active', '=', False) 条件。它将默认只限制搜索到活动记录。

添加具有可配置精度的浮点字段

当使用 float 字段时，我们可能希望让最终用户配置将要使用的十进制精度。在本菜谱中，我们将向 hostel 模型添加一个 hostel_rating 字段，并允许用户配置十进制精度。

准备工作

我们将继续使用前一个菜谱中的 my_hostel 扩展模块。

如何做到这一点...

执行以下步骤以将动态十进制精度应用于模型的 hostel_rating 字段：

创建一个数据文件夹并添加一个 data.xml 文件。在此文件中，为十进制精度模型添加以下记录。这将添加一个新的配置。

<record forcecreate="True" id="decimal_point" model="decimal.precision">
<field name="name">Rating Value</field>
<field name="digits">3</field>
</record>

从设置菜单中的链接激活开发者模式（参考第一章，安装 Odoo 开发环境中的激活 Odoo 开发者工具配方）。这将启用设置 | 技术菜单。
访问小数精度配置。为此，打开设置顶部菜单并选择技术 | 数据库结构 | 小数精度。我们应该能看到当前定义的设置列表。

图 4.2 – 创建新的小数精度

要使用此小数精度设置添加model字段，请通过编辑models/hostel.py文件并添加以下代码：

class Hostel(models.Model):
    hostel_rating = fields.Float('Hostel Average Rating',
    # digits=(14, 4) # Method 1: Optional precision (total, decimals),
    digits='Rating Value' # Method 2
)

它是如何工作的...

当您向字段的digits属性添加一个字符串值时，Odoo 会在小数精度模型的Usage字段中查找该字符串，并返回一个元组，具有 16 位精度和配置中定义的小数位数。使用字段定义，而不是将其硬编码，我们允许最终用户根据其需求进行配置。

向模型添加货币字段

要在模型中处理货币值和货币，我们可以使用 Odoo 通过使用特定的字段类型和功能来提供对货币值和货币的特殊支持。Odoo 对货币值和货币的特殊支持简化了财务数据的处理，确保准确性、一致性和符合货币相关要求。

准备工作

我们将使用之前配方中的相同my_hostel附加模块。

如何操作…

我们需要添加一个货币字段以及一个货币字段来存储金额的货币。

我们将添加models/hostel_room.py，以添加必要的字段：

创建字段以存储金额的货币：

class HostelRoom(models.Model):
    _name = "hostel.room"
    …#
    currency_id = fields.Many2one('res.currency', string='Currency')

添加货币字段以存储金额：

class HostelRoom(models.Model):
    _name = "hostel.room"
    …#
    rent_amount = fields.Monetary('Rent Amount', help="Enter rent amount per month") # optional attribute: currency_field='currency_id' incase currency field have another name then 'currency_id'

为新模型创建一个安全文件和一个表单视图以在 UI 中显示它。升级附加模块以应用更改。货币字段将显示如下：

图 4.3 – 货币字段中的货币符号

它是如何工作的…

Odoo 可以正确地在用户界面中显示货币字段，因为它们有一个表示其货币的第二个字段。这个字段类似于一个浮点字段。

货币字段通常命名为currency_id，但我们可以使用任何其他名称，只要我们使用可选的currency_field参数指定它。

如果您的货币信息存储在名为currency_id的字段中，您不需要为货币字段指定currency_field属性。

当您需要在同一记录中存储不同货币的金额时，这很有用。例如，如果您想有销售订单和公司的货币，您可以创建两个字段作为fields.Many2one(res.currency)，并为每个金额使用一个。

货币定义（res.currency model 的 decimal_precision 字段）决定了金额的小数精度。

向模型添加关系字段

关系字段用于表示 Odoo 模型之间的关系。有三种类型的关系：

多对一，或简称为 m2o
一对一，或简称为 o2m
多对多，或简称为 m2m

为了说明这一点，让我们考虑宿舍房间模型。一个房间属于一个单独的宿舍，因此宿舍和房间之间的关系是 m2o。然而，一个宿舍可以有多个房间，所以相反的关系是 o2m。

我们还可以有一个 m2m 关系。例如，一个房间可以提供各种便利设施，便利设施可以在不同的房间中可用。这是一个双向的 m2m 关系。

准备工作

我们将继续使用之前菜谱中的 my_hostel 附加模块。

如何做到这一点...

我们将编辑 models/hostel_room.py 文件以添加这些字段：

在 Hostel Room 中添加 m2o 字段：

class HostelRoom(models.Model):

# ...
    hostel_id = fields.Many2one("hostel.hostel", "hostel", help="Name of hostel")

我们想为一名学生创建一个链接到房间的 o2m 字段。
首先，我们需要一个新的宿舍学生模型。我们将创建一个 hostel_student.py 文件，并向宿舍学生模型添加一些基本字段。然后，我们将添加一个 room_id m2o 字段来连接学生和房间模型。

最后，我们将向 hostel.room 模型添加一个 o2m 字段，student_ids，来自 hostel.student 模型：

class HostelStudent(models.Model):
    _name = "hostel.student"
    name = fields.Char("Student Name")
    gender = fields.Selection([("male", "Male"),
    ("female", "Female"), ("other", "Other")],
    string="Gender", help="Student gender")
    active = fields.Boolean("Active", default=True,
    help="Activate/Deactivate hostel record")
    room_id = fields.Many2one("hostel.room", "Room",
help="Select hostel room")
class HostelRoom(models.Model):
    _name = "hostel.room"
    # ...
    student_ids = fields.One2many("hostel.student", "room_id",
    string="Students", help="Enter students")

我们将创建一个新的文件，hostel_amenities.py。将以下代码添加到该文件中：

class HostelAmenities(models.Model):
    _name = "hostel.amenities"
    _description = "Hostel Amenities"
    name = fields.Char("Name", help="Provided Hostel Amenity")
    active = fields.Boolean("Active",
    help="Activate/Deactivate whether the amenity should be given or not")

现在，我们将向 hostel.room 模型添加一个便利设施的 m2m 字段。将以下代码添加到 hostel_room.py 文件中：

class HostelRoom(models.Model):
    _name = "hostel.room"
    # ...
    hostel_amenities_ids = fields.Many2many("hostel.amenities",
    "hostel_room_amenities_rel", "room_id", "amenitiy_id",
    string="Amenities", domain="[('active', '=', True)]",
    help="Select hostel room amenities")

现在，升级附加模块，新字段应该可以在模型中找到。除非将它们添加到视图中，否则它们在视图中是不可见的。我们将向 hostel_room.xml 文件中添加新字段。

我们可以通过检查设置 | 技术 | 数据库结构 | 模型中的 开发者 模式下的 model 字段来确认它们的添加。

它是如何工作的…

m2o 字段存储模型表列中另一个记录的数据库 ID。这将在数据库中创建一个外键约束，确保存储的 ID 是对另一个表中记录的有效引用。默认情况下，这些关系字段没有数据库索引，但您可以通过设置 index=True 属性来添加一个。

您还可以指定当引用 m2o 字段的记录被删除时会发生什么。ondelete 属性控制这种行为。例如，当学生的房间记录被删除时，应该发生什么？默认选项是 'set null'，这意味着字段将具有空值。另一个选项是 'restrict'，这意味着相关的记录不能被删除。第三个选项是 'cascade'，这意味着链接的记录也将被删除。

您也可以为其他关系字段使用 context 和 domain。这些属性主要在客户端有用，并为通过字段访问的相关记录视图提供默认值：

context 在您点击字段以查看相关记录视图时，在客户端上下文中设置一些变量。例如，您可以使用它为此视图中创建的新记录设置默认值。
domain 是一个过滤器，限制了您可以从中选择的关联记录列表。

您可以在第九章 后端视图中了解更多关于 context 和 domain 的信息。

o2m 字段是 m2o 字段的相反，它允许您从模型访问相关记录列表。与其他字段不同，它不在数据库表中具有列。它只是方便地在视图中显示这些相关记录的一种方式。要使用 o2m 字段，您需要在其他模型中有一个相应的 m2o 字段。在我们的示例中，我们在房间模型中添加了一个 o2m 字段。student_ids o2m 字段引用了 hostel.room 模型的 room_id 字段。

m2m 字段在模型的表中没有列。相反，它使用数据库中的另一个表来存储两个模型之间的关系。此表有两个列，用于存储相关记录的 ID。当您使用 m2m 字段将房间及其设施链接起来时，在此表中创建一个新记录，包含房间的 ID 和设施的 ID。

Odoo 会为您创建关系表。默认情况下，关系表的名称是由两个模型的名称组成，按字母顺序排序，并带有 _rel 后缀。您可以使用 relation 属性更改此名称。

当两个模型的名称对于默认名称来说太长时，您应该使用 relation 属性。PostgreSQL 对数据库标识符的长度限制为 63 个字符。因此，如果两个模型的名称每个都超过 23 个字符，您应该使用 relation 属性设置一个较短的名称。我们将在下一节中进一步解释这一点。

还有更多...

您还可以为 m2o 字段使用 auto_join 属性。此属性允许 ORM 在此字段上使用 SQL 连接。这意味着 ORM 不会检查此字段的用户访问控制和记录访问规则。在某些情况下，这可以帮助解决性能问题，但最好避免这样做。

我们已经看到了定义关系字段的最简单方法。现在，让我们看看这些字段特有的属性。

这些是 o2m 字段的属性：

comodel_name：这是字段所关联的模型的名称。您需要此属性用于所有关系字段。您可以不带关键字作为第一个参数来编写它。
inverse_name：这仅适用于 o2m 字段。它是其他模型中链接回此模型的 m2o 字段的名称。
limit：这是针对o2m和m2m字段的。它设置用户界面中读取和显示的最大记录数。

这些是m2m字段的属性：

comodel_name：这是字段关联的模型的名称。它与o2m字段相同。
relation：这是数据库中存储关系的表的名称。您可以使用此属性来更改默认名称。
column1：这是关系表中链接到此模型的第 1 列的名称。
column2：这是关系表中链接到其他模型的第 2 列的名称。

Odoo 通常自动处理这些属性的创建和管理。它可以识别并利用现有关系表来处理逆m2m字段。然而，在某些特定场景中需要手动干预。

当处理同一两个模型之间的多个m2m字段时，有必要为每个字段分配不同的关系表名称。

在两个模型的名称超过 PostgreSQL 对数据库对象名称的 63 个字符限制的情况下，您必须自己设置这些属性。默认的关系表名称通常是<model1>_<model2>rel。然而，此表包含一个较长的名称的索引（<model1><model2>rel<model1>id<model2>_id_key），这也需要遵守 63 个字符的限制。因此，如果两个模型的组合名称超过此限制，您必须选择较短的关系表名称。

为模型添加层次结构

您可以使用m2o字段来表示层次结构，其中每个记录都有一个父记录和同一模型中的多个子记录。然而，Odoo 还通过使用嵌套集模型(en.wikipedia.org/wiki/Nested_set_model)来提供对此类字段的支持。当激活时，在域过滤器中使用child_of运算符的查询将显著加快。

以“宿舍”为例，我们将构建一个可以用于分类宿舍的层次结构分类树。

准备工作

我们将继续使用前一个菜谱中的my_hostel附加模块。

如何操作...

我们将为分类树添加一个新的 Python 文件，models/hostel_categ.py，如下所示：

要加载新的 Python 代码文件，请将以下行添加到models/__init__.py：
```
from . import Hostel Category model with the parent and child relationships, create the models/hostel_categ.py file with the following code:
```
from odoo import models, fields, api

class HostelCategory(models.Model):

_name = "hostel.category"

name = fields.Char('类别')

parent_id = fields.Many2one(

'hostel.category',

string='父类别',

ondelete='restrict',

index=True)

parent_path = fields.Char(index=True)

child_ids = fields.One2many(

'hostel.category', 'parent_id',

string='子类别')

为了启用特殊的层次结构支持，还需要添加以下代码：

_parent_store = True
_parent_name = "parent_id" # optional if field is 'parent_id'
parent_path = fields.Char(index=True, unaccent=False)

要添加检查以防止循环关系，请将以下行添加到模型中：

from odoo.exceptions import ValidationError
...
@api.constrains('parent_id')
def _check_hierarchy(self):
    if not self._check_recursion():
        raise models.ValidationError(
            'Error! You cannot create recursive categories.')

现在，我们需要为一家旅舍分配一个类别。为此，我们将在hostel.hostel模型中添加一个新的m2o字段：
```
category_id = fields.Many2one('hostel.category')
```

最后，模块升级将使这些更改生效。

要在用户界面中显示hostel.category模型，您需要添加菜单、视图和安全性规则。有关更多详细信息，请参阅第三章，创建 Odoo 附加模块。或者，您也可以访问所有代码github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter04。

它是如何工作的...

我们想创建一个新的具有层次关系的模型。这意味着每个记录都可以在同一模型中有一个父记录和多个子记录。以下是完成此操作的步骤：

我们创建了一个m2o字段来引用父记录。我们使用index=True来使此字段在数据库中索引，以便更快地进行查询。我们还使用ondelete='cascade'或ondelete='restrict'来控制当父记录被删除时会发生什么。
我们创建一个o2m字段来访问一个记录的所有子记录。这个字段不会向数据库添加任何内容，但它是一种方便获取子记录的方法。我们通过在模型属性中使用parent_store=True来添加对层次结构的特殊支持。这使得使用child_of运算符的查询更快，但同时也使得写操作变慢。我们还添加了一个名为parent_path的辅助字段来存储用于层次结构搜索的数据。如果我们为父字段使用与parent_id不同的名称，我们需要在模型属性中使用parent_name来指定它。
我们通过使用models.Model中的_check_recursion方法来防止层次结构中的循环依赖。这避免了我们有一个既是另一个记录的祖先又是后代的记录，这可能导致无限循环。
我们在hostel.hostel模型中添加了一个category_id字段，类型为Many2one，以便我们可以为每个旅舍分配一个类别。这只是为了完成我们的示例。

还有更多...

您应该使用这种技术来处理层次结构变化不大但读取和查询频繁的情况。这是因为数据库中的嵌套集模型需要在添加、删除或移动类别时更新所有记录的parent_path列（和相关数据库索引）。这可能会很慢且成本高昂，尤其是在有大量并发事务的情况下。

如果您的层次结构经常变化，您可能会通过使用标准的parent_id和child_ids关系获得更好的性能。这样，您可以避免表级锁定。

向模型添加约束验证

我们想确保我们的模型没有无效或不一致的数据。Odoo 有两种类型的约束来完成这项工作：

数据库级别的约束：这是 PostgreSQL 支持的约束。最常见的是UNIQUE约束，它防止重复值。我们还可以使用CHECK和EXCLUDE约束来满足其他条件。这些约束快速且可靠，但它们受限于 PostgreSQL 能做什么。
服务器级别的约束：这是我们编写的 Python 代码中的约束。当数据库级别的约束不足以满足我们的需求时，我们可以使用这些约束。这些约束更灵活且功能强大，但它们较慢且更复杂。

准备工作

我们将继续使用之前配方中的my_hostel附加模块。我们将使用宿舍房间模型并向其添加一些约束。我们将使用来自第三章的宿舍房间模型，创建 Odoo 附加模块，并向其添加一些约束。

我们将使用一个UNIQUE约束来确保房间号码不会重复。我们还将添加一个 Python 模型约束来检查租金金额是否为正。

如何操作...

SQL 约束是通过_sql_constraints模型属性定义的。此属性被分配一个包含字符串(name, sql_definition, message)的三元组列表，其中name是有效的 SQL 约束名称，sql_definition是table_constraint表达式，message是错误消息。我们可以在hostel.room模型中添加以下代码：
```
_sql_constraints = [
   ("room_no_unique", "unique(room_no)", "Room number must be unique!")]
```
一个检查记录集中条件的方法。我们使用constrains()装饰器标记方法为约束，并指示哪些字段参与了条件。当这些字段中的任何一个被更改时，将自动检查约束。如果条件不满足，方法应抛出异常：
```
from odoo.exceptions import ValidationError
...
 @api.constrains("rent_amount")
     def _check_rent_amount(self):
        """Constraint on negative rent amount"""
        if self.rent_amount < 0:
        raise ValidationError(_("Rent Amount Per Month should not be a negative value!"))
```
在对代码文件进行这些更改后，您需要升级附加模块并重新启动服务器。

注意

如果你通过模型继承将 SQL 约束添加到现有模型中，请确保没有违反约束的行。如果你有此类行，则不会添加 SQL 约束，并在日志中生成错误。

有关 PostgreSQL 约束的一般信息和特定于表的约束的更多信息，请参阅www.postgresql.org/docs/current/static/ddl-constraints.html。

它是如何工作的...

我们可以使用 Python 代码来验证我们的模型并防止无效数据。为此，我们使用两个东西：

一个检查记录集中条件的方法。我们使用constrains()装饰器标记方法为约束，并指示哪些字段参与了条件。当这些字段中的任何一个被更改时，将自动检查约束。

当条件不满足时，我们抛出的ValidationError异常。此异常向用户显示错误消息并停止操作。

向模型添加计算字段

我们可能想要创建一个字段，该字段依赖于同一记录或相关记录中其他字段的值。例如，我们可以通过将单价乘以数量来计算总额。在 Odoo 模型中，我们可以使用计算字段来完成这项工作。

为了演示计算字段的工作原理，我们将在宿舍房间模型中添加一个计算字段，该字段根据学生入住情况计算房间可用性。

我们还可以使计算字段可编辑和可搜索。我们将在我们的示例中向您展示如何做到这一点。

准备工作

我们将继续使用之前菜谱中的my_hostel附加模块。

如何做到这一点...

我们将修改models/hostel_room.py代码文件，以包含一个新字段及其实现逻辑的方法：

计算字段的值通常依赖于同一记录中其他字段的值。ORM 要求开发者在compute方法中使用depends()装饰器声明这些依赖关系。ORM 使用给定的依赖关系，在任何一个依赖关系发生变化时重新计算字段。首先，将新字段添加到Hostel Rooms模型中：

student_per_room = fields.Integer("Student Per Room", required=True,help="Students allocated per room")'
availability = fields.Float(compute="_compute_check_availability",string="Availability", help="Room availability in hostel")
@api.depends("student_per_room", "student_ids")
def _compute_check_availability(self):
    """Method to check room availability"""
    for rec in self:
rec.availability = rec.student_per_room - len(rec.student_ids.ids)

默认情况下，计算字段是只读的，因为用户不应输入值。

然而，在某些情况下，允许用户直接设置值可能是有帮助的。例如，在我们的宿舍学生场景中，我们将添加入学日期、出院日期和持续时间。我们希望用户能够输入持续时间或出院日期，其他值将相应更新：

admission_date = fields.Date("Admission Date",
    help="Date of admission in hostel",
    default=fields.Datetime.today)
discharge_date = fields.Date("Discharge Date",
    help="Date on which student discharge")
duration = fields.Integer("Duration",  compute="_compute_check_duration", inverse="_inverse_duration", help="Enter duration of living")
@api.depends("admission_date", "discharge_date")
def _compute_check_duration(self):
    """Method to check duration"""
    for rec in self:
        if rec.discharge_date and rec.admission_date:
            rec.duration = (rec.discharge_date - rec.admission_date).days
def _inverse_duration(self):
    for stu in self:
        if stu.discharge_date and stu.admission_date:
            duration = (stu.discharge_date - stu.admission_date).days
            if duration != stu.duration:
                stu.discharge_date = (stu.admission_date + timedelta(days=stu.duration)).strftime('%Y-%m-%d')

计算方法将值分配给字段，而逆方法将值分配给字段的依赖关系。

注意，当记录保存时调用逆方法，而计算方法在其依赖关系中的任何一个发生变化时都会被调用。

计算字段默认情况下不存储在数据库中。一种解决方案是将字段存储为具有store=True属性：
```
availability = fields.Float(compute="_compute_check_availability", store=True, string="Availability", help="Room availability in hostel")
```
由于计算字段默认情况下不存储在数据库中，除非我们使用store=True属性或添加一个search方法，否则无法对计算字段进行搜索。

它是如何工作的...

计算字段看起来像一个普通字段，但它有一个compute属性，该属性指定了计算其值的方法的名称。

然而，计算字段在内部并不等同于普通字段。计算字段在运行时即时计算，因此它们不存储在数据库中，所以默认情况下无法对它们进行搜索或写入。您需要做一些额外的工作来启用对它们的写入和搜索支持。让我们看看如何做。

计算方法在运行时即时计算，但 ORM 使用缓存来避免每次访问其值时都无必要地重新计算。因此，它需要知道它依赖于哪些其他字段。它使用@depends装饰器来确定何时应该使缓存的值无效并重新计算。

确保计算方法始终为计算字段分配一个值。否则，将发生错误。这可能会发生在您的代码中有条件有时未能为计算字段分配值的情况下。这可能很难调试。

通过实现inverse方法可以添加写入支持。这使用分配给计算字段的值来更新源字段。当然，这仅适用于简单计算。然而，仍然有一些情况下它可能很有帮助。在我们的例子中，我们通过编辑持续时间天数来使设置排放日期成为可能，因为Duration是一个计算字段。

inverse属性是可选的；如果您不想使计算字段可编辑，可以跳过它。

还可以通过将search属性设置为方法名（类似于compute和inverse）来使非存储计算字段可搜索。与inverse一样，search也是可选的；如果您不想使计算字段可搜索，可以跳过它。

然而，这种方法不应该执行实际的搜索。相反，它接收用于在字段上搜索的操作符和值作为参数，并应该返回一个域，其中包含要使用的替代搜索条件。

可选的store=True标志将字段存储在数据库中。在这种情况下，计算后，字段值存储在数据库中，并且从那时起，它们以与常规字段相同的方式检索，而不是在运行时重新计算。多亏了@api.depends装饰器，ORM 将知道何时需要重新计算和更新这些存储值。您可以将它视为持久缓存。它还有使字段可用于搜索条件的好处，包括排序和按操作分组。如果您在计算字段中使用store=True，则不再需要实现search方法，因为该字段存储在数据库中，并且可以基于它进行搜索/排序。

compute_sudo=True标志用于需要以更高权限执行计算的情况。这可能是在计算需要使用可能对最终用户不可访问的数据时所需的。

注意

在 Odoo v13 中，compute_sudo的默认值发生了变化。在 Odoo v13 之前，compute_sudo的值是False，但在 v13 中，compute_sudo的默认值取决于store属性。如果store属性是True，则compute_sudo是True；否则，它是False。但是，您可以通过在字段定义中显式设置compute_sudo来始终覆盖它。

还有更多...

Odoo v13 为 ORM 引入了一种新的缓存机制。以前，缓存是基于环境的，但现在，在 Odoo v13 中，有一个全局缓存。因此，如果您有一个依赖于上下文值的计算字段，有时您可能会得到错误值。为了解决这个问题，您需要使用@api.depends_context装饰器。请参考以下示例：

    @api.depends('price')
    @api.depends_context('company_id')
    def _compute_value(self):
        company_id = self.env.context.get('company_id')
       ...
       # other computation

你可以在前面的例子中看到，我们的计算使用了上下文中的company_id。通过在depends_context装饰器中使用company_id，我们确保字段值将根据上下文中company_id的值重新计算。

暴露存储在其他模型中的相关字段

Odoo 客户端只能读取他们查询的模型所属的字段数据。他们不能像服务器端代码那样使用点符号访问相关表中的数据。

然而，我们可以通过添加相关字段来使相关表中的数据对客户端可用。这就是我们将如何获取学生模型中房间的宿舍。

准备工作

我们将继续使用之前菜谱中的my_hostel附加模块。

如何操作...

编辑models/hostel_student.py文件以添加新的related字段。

确保我们有一个宿舍房间字段，然后，我们添加一个新的关联字段来将学生与他们的宿舍联系起来：

class HostelStudent(models.Model):
    _name = "hostel.student"
    # ...
    hostel_id = fields.Many2one("hostel.hostel", related='room_id.hostel_id')

最后，我们需要升级附加模块，以便新字段可以在模型中使用。

它是如何工作的...

相关字段是一种特殊类型的字段，它引用来自不同记录的另一个字段。要创建相关字段，我们需要指定related属性，并给出一个显示要跟随的字段路径的字符串。例如，我们可以创建一个显示学生房间宿舍的相关字段，通过遵循room_id.hostel_id路径。

使用引用字段添加动态关系

使用关系字段，我们需要事先决定关系的目标模型（或共同模型）。然而，有时我们可能需要将此决定留给用户，首先选择我们想要的模型，然后选择我们想要链接的记录。

使用 Odoo，这可以通过引用字段实现。

准备工作

我们将继续使用之前菜谱中的my_hostel附加模块。

如何操作...

编辑models/hostel.py文件以添加新的相关字段：

首先，我们需要添加一个辅助方法来动态构建可选择的目标模型列表：

from odoo import models, fields, api
class Hostel(models.Model):
_name = 'hostel.hostel'
    # ...
    @api.model
    def _referencable_models(self):
        models = self.env['ir.model'].search([
            ('field_id.name', '=', 'message_ids')])
        return [(x.model, x.name) for x in models]

然后，我们需要添加引用字段并使用之前的函数提供可选择的模型列表：

    ref_doc_id = fields.Reference(
        selection='_referencable_models',
        string='Reference Document')

由于我们正在更改模型的结构，因此需要模块升级以激活这些更改。

它是如何工作的...

引用字段类似于m2o字段，但它们允许用户选择要链接到的模型。

目标模型可以从由selection属性提供的列表中选择。selection属性必须是一个包含两个元素的元组的列表，其中第一个是模型的内部标识符，第二个是对它的文本描述。

这里有一个例子：

[('res.users', 'User'), ('res.partner', 'Partner')]

然而，而不是提供一个固定的列表，我们可以使用最常用的模型。为了简单起见，我们使用了具有消息功能的全部模型。使用_referencable_models方法，我们动态地提供了一个模型列表。

我们的配方从提供一个函数开始，该函数可以浏览所有可引用的模型记录，以动态构建一个将提供给selection属性的列表。尽管两种形式都是允许的，但我们声明了带引号的函数名，而不是直接引用不带引号的函数。这更加灵活，并允许在代码中稍后定义引用的函数，例如，这是在使用直接引用时不可能做到的。

该函数需要@api.model装饰器，因为它在模型级别上操作，而不是在记录集级别上。

虽然这个功能看起来不错，但它带来了显著的执行开销。在大量记录（例如，在列表视图中）显示引用字段可能会创建沉重的数据库负载，因为每个值都需要在单独的查询中进行查找。与常规关系字段不同，它也无法利用数据库引用完整性。

使用继承向模型添加功能

Odoo 拥有一个强大的功能，可以显著增强其灵活性和功能性，这对于寻求定制解决方案的企业尤其有益。此功能允许集成模块附加组件，使它们能够增强现有模块的功能，而无需修改其底层代码库。这是通过添加或修改字段和方法，以及通过扩展当前方法并添加补充逻辑来实现的。这种模块化方法不仅促进了可定制和可扩展的系统，而且还确保了升级和维护保持流畅，防止了与自定义修改通常相关的复杂性。

官方文档描述了 Odoo 中的三种继承方式：

类继承（扩展）
原型继承
委托继承

我们将在单独的配方中看到这些内容。在这个配方中，我们将看到类继承（扩展）。这是用来向现有模型添加新字段或方法的。

我们将扩展现有的合作伙伴模型 res.partner，使其包含一个计算每个用户分配了多少宿舍房间的计算字段。这将有助于确定每个房间分配给哪个部分以及哪个用户占用它。

准备工作

我们将继续使用前一个菜谱中的 my_hostel 附加模块。

如何做...

我们将扩展内置的合作伙伴模型。如果您记得，我们已经在本章的 向模型添加关系字段 菜谱中继承了 res.parnter 模型。为了使解释尽可能简单，我们将在 models/hostel_book.py 代码文件中重用 res.partner 模型：

首先，我们将确保 authored_book_ids 反向关系在合作伙伴模型中，并添加计算字段：

class ResPartner(models.Model):
   _inherit = "res.partner"
   is_hostel_rector = fields.Boolean("Hostel Rector", help="Activate if the following person is hostel rector")
   assign_room_ids = fields.Many2many('library.book',string='Authored Books')
   count_assign_room = fields.Integer( 'Number of Authored Books', compute="_compute_count_room")

接下来，添加计算书籍数量的所需方法：

@api.depends('assign_room_ids')
   def _compute_count_room(self):
       for partner in self:
           partner.count_assign_room = len(partner.assign_room_ids)

最后，我们需要升级附加模块以使修改生效。

它是如何工作的...

当使用 _inherit 属性定义模型类时，它向继承的模型添加修改，而不是替换它。

这意味着在继承类中定义的字段被添加或更改到父模型中。在数据库层，ORM 将字段添加到同一数据库表中。

字段也逐步修改。这意味着如果字段已经在超类中存在，则仅修改继承类中声明的属性；其他属性保持与父类中相同。

继承类中定义的方法将替换父类中的方法。如果您不使用 super 调用父方法，则父方法的版本将不会执行，我们将失去功能。因此，每次您通过继承现有方法添加新逻辑时，都应该包含一个带有 super 的语句来调用其父类中的版本。这将在 第五章 的基本 服务器端开发 中更详细地讨论。

此菜谱将为现有模型添加新字段。如果您还希望将这些新字段添加到现有视图中（用户界面），请参阅 第九章 的 更改现有视图 – 视图继承 菜谱，后端视图。

使用继承复制模型定义

我们在前一个菜谱中看到了类继承（扩展）。现在，我们将看到 hostel.room 模型。

准备工作

我们将继续使用前一个菜谱中的 my_hostel 附加模块。

如何做...

原型继承是通过同时使用 _name 和 _inherit 类属性来执行的。执行以下步骤以生成 hotel.room 模型的副本：

在 /my_hostel/models/ 目录下添加一个名为 hostel_room_copy.py 的新文件。

将以下内容添加到 hostel_room_copy.py 文件中：

from odoo import fields, models, api, _
class HostelRoomCopy(models.Model):
   _name = "hostel.room.copy"
   _inherit="hostel.room"
   _description = "Hostel Room Information Copy"

将新文件引用导入 /my_library/models/__init__.py 文件。在更改之后，您的 __init__.py 文件将看起来像这样：
```
from . import hostel_room
from . import hostel_room_copy
```
最后，我们需要升级附加模块以使修改生效。
要检查新模型的定义，请转到这里的 hostel.room.copy 模型。

小贴士

为了查看新模型的菜单和视图，你需要添加视图和菜单的 XML 定义。要了解更多关于视图和菜单的信息，请参考 第三章 中的 添加菜单项和视图食谱，创建 Odoo 附加模块。

它是如何工作的...

通过同时使用 _name 和 _inherit 类属性，你可以复制模型的定义。当你在这两个属性中使用模型时，Odoo 将复制 _inherit 的模型定义，并创建一个具有 _name 属性的新模型。

在我们的例子中，Odoo 将复制 Hostel.room 模型的定义并创建一个新的模型，名为 hostel.room.copy。新的 hostel.room.copy 模型拥有自己的数据库表和独立于 hostel.room 父模型的自己的数据。由于它仍然继承自合作伙伴模型，对它的任何后续修改也将影响新的模型。

原型继承复制父类的所有属性。它复制字段、属性和方法。如果你想在子类中修改它们，你只需在子类中添加一个新的定义即可。例如，hostel.room 模型有 _name_get 方法。如果你想在子类中使用不同的 _name_get 版本，你需要重新定义 hostel.room.copy 模型中的方法。

注意

如果你在 _inherit 和 _name 属性中使用相同的模型名称，原型继承将不起作用。如果你确实在 _inherit 和 _name 属性中使用相同的模型名称，它将表现得像正常的扩展继承。

还有更多...

在官方文档中，这被称为原型继承，但在实践中，它很少被使用。原因是委托继承通常以更有效的方式满足这种需求，而不需要复制数据结构。有关更多信息，请参考下一道食谱，使用委托继承将功能复制到另一个模型。

使用委托继承将功能复制到另一个模型

第三种继承类型是委托继承。它不使用 _inherit，而是使用 _inherits 类属性。有些情况下，我们不想修改现有的模型，而是想基于现有的模型创建一个新的模型来使用它已有的功能。我们可以使用原型继承复制模型定义，但这将生成重复的数据结构。如果你想在复制模型定义时不重复数据结构，那么答案就在 Odoo 的委托继承中，它使用 _inherits 模型属性（注意额外的 s）。

传统继承与面向对象编程中同名概念的差异很大。委托继承，反过来，在创建一个新模型以包含父模型的功能方面是相似的。它还支持多态继承，其中我们可以从两个或更多其他模型继承。

我们运营一个既提供房间又容纳学生的宿舍。为了更好地管理我们的住宿，将学生相关信息整合到我们的系统中至关重要。具体来说，对于每个学生，我们需要全面的身份和地址信息，类似于合作伙伴模型中捕获的信息。此外，维护与房间分配相关的记录也非常关键，包括每个学生入住的开始和结束日期以及他们的卡号。

直接将这些字段添加到现有的合作伙伴模型中并不是一个理想的方法，因为这会在模型中无谓地添加与学生特定的数据，这些数据对于非学生合作伙伴来说是不相关的。一个更有效的解决方案是通过创建一个新的模型来增强合作伙伴模型，该模型从它继承并引入了管理学生信息所需的所有额外字段。这种方法确保了一个更干净、更有组织、功能更高效的系统，以满足我们宿舍的独特需求。

准备工作

我们将继续使用之前菜谱中的 my_hostel 附加模块。

如何操作...

新的图书馆会员模型应该有自己的 Python 代码文件，但为了尽可能简化说明，我们将重用 models/hostel_student.py 文件：

添加继承自 res.partner 的新模型：

class HostelStudent(models.Model):
   _name = "hostel.student"
   _inherits = {'res.partner': 'partner_id'}
   _description = "Hostel Student Information"
   ………
   partner_id = fields.Many2one('res.partner', ondelete='cascade')

接下来，我们将添加每个学生特有的字段：

gender = fields.Selection([("male", "Male"),
       ("female", "Female"), ("other", "Other")],
       string="Gender", help="Student gender")
   room_id = fields.Many2one("hostel.room", "Room",
       help="Select hostel room")

现在，我们将升级附加模块以激活更改。

它是如何工作的...

_inherits 模型属性设置了我们想要继承的父模型。在这种情况下，我们只有一个——res.partner。其值是一个键值字典，其中键是继承的模型，值是用于链接它们的字段名称。这些是必须也在模型中定义的 m2o 字段。在我们的例子中，partner_id 是将用于与 Partner 父模型链接的字段。

为了更好地理解它是如何工作的，让我们看看当我们创建一个新会员时在数据库级别上会发生什么：

在 res_partner 表中创建了一个新记录。
在 hostel_student 表中创建了一个新记录。
hostel_student 表的 partner_id 字段被设置为为其创建的 res_partner 记录的 ID。

会员记录自动链接到一个新的合作伙伴记录。这只是一个 m2o 关系，但委托机制添加了一些魔法，使得合作伙伴的字段看起来就像属于会员记录一样，并且也会自动创建一个新的合作伙伴记录。

你可能想知道，这个自动创建的合作伙伴记录并没有什么特别之处。它是一个普通的合作伙伴，如果你浏览合作伙伴模型，你将能够找到那条记录（当然，不包括额外的成员数据）。所有成员都是合作伙伴，但只有一些合作伙伴也是成员。那么，如果你删除了一个也是成员的合作伙伴记录会发生什么呢？你可以通过为关系字段选择ondelete值来决定。对于partner_id，我们使用了cascade。这意味着删除合作伙伴也会删除相应的成员。我们本来可以使用更保守的设置restrict来禁止在合作伙伴有链接成员的情况下删除合作伙伴。在这种情况下，只有删除成员才会生效。

重要的是要注意，委托继承仅适用于字段，不适用于方法。所以，如果合作伙伴模型有一个do_something()方法，成员模型将不会自动继承它。

还有更多...

对于这种继承委托有一个快捷方式。你不需要创建一个_inherits字典，你可以在m2o字段定义中使用delegate=True属性。这将与_inherits选项完全一样。主要优势是这更简单。在给定的例子中，我们执行了与上一个例子相同的继承委托，但在这个例子中，我们不是创建一个_inherits字典，而是在partner_id字段中使用了delegate=True选项：

class HostelStudent(models.Model):
   _name = "hostel.student"
   _description = "Hostel Student Information"
   partner_id = fields.Many2one('res.partner', ondelete='cascade', delegate=True)

委托继承的一个值得注意的案例是用户模型，res.users。它从合作伙伴（res.partner）继承。这意味着用户上可以看到的一些字段实际上存储在合作伙伴模型中（特别是name字段）。当创建新用户时，我们也会得到一个新的、自动创建的合作伙伴。

我们还应该提到，使用_inherit的传统继承也可以将功能复制到新模型中，尽管效率较低。这在使用继承向模型添加功能的菜谱中已经讨论过。

使用抽象模型实现可重用模型功能

有时，我们希望能够在几个不同的模型中添加特定的功能。在不同的文件中重复相同的代码是一种不良的编程实践；最好是实现一次并重用它。

抽象模型允许我们创建一个通用的模型，该模型实现了一些功能，然后这些功能可以被常规模型继承，以便使该功能可用。

作为例子，我们将实现一个简单的存档功能。这将在模型中添加active字段（如果尚未存在）并使存档方法可用以切换active标志。这是因为active是一个魔法字段。如果它默认存在于模型中，则带有active=False的记录将被从查询中过滤出来。然后我们将它添加到hostel room模型中。

准备工作

我们将继续使用上一个菜谱中的my_hostel附加模块。

如何做到这一点...

存档功能确实值得拥有自己的附加模块，或者至少是自己的 Python 代码文件。然而，为了使解释尽可能简单，我们将它塞入models/hostel_room.py文件中：

添加存档功能的抽象模型。它必须在库书籍模型中定义，在那里它将被使用：

class BaseArchive(models.AbstractModel):
   _name = 'base.archive'
   active = fields.Boolean(default=True)
   def do_archive(self):
       for record in self:
           record.active = not record.active

现在，我们将编辑宿舍房间模型以继承存档模型：

class HostelRoom(models.Model):
   _name = "hostel.room"
   _inherit = ['base.archive']

为了激活更改，需要升级附加模块。

它是如何工作的...

抽象模型是通过基于models.AbstractModel的类创建的，而不是通常的models.Model。它具有常规模型的所有属性和能力；区别在于 ORM 不会在数据库中为它创建实际表示。这意味着它不能存储任何数据。它仅作为将添加到常规模型的可重复使用功能的模板。

我们的存档抽象模型相当简单。它只是添加了active字段和一个用于切换active标志值的方法，我们预计将来将通过用户界面上的按钮使用它。当一个模型类使用_inherit属性定义时，它将继承这些类的属性方法，而当前类中定义的属性方法将对继承的功能进行修改。

这里所涉及的机制与常规模型扩展（如根据使用继承向模型添加功能的配方）相同。你可能已经注意到_inherit使用的是模型标识符的列表，而不是单个模型标识符的字符串。实际上，_inherit可以同时采用这两种形式。使用列表形式允许我们从多个（通常是Abstract）类中继承。在这种情况下，我们只继承了一个，所以使用文本字符串就足够了。这里使用列表是为了说明。

还有更多...

值得注意的是，内置的抽象模型之一是mail.thread，它由mail (Discuss)附加模块提供。在模型上，它启用了许多表单底部看到的消息墙的讨论功能。

除了AbstractModel之外，还有一种第三种模型类型可用——models.TransientModel。它具有与models.Model类似的数据库表示，但创建在该处的记录应该是临时的，并且由服务器计划的任务定期清除。除此之外，临时模型的工作方式与常规模型相同。

models.TransientModel对于更复杂的用户交互非常有用，这种交互被称为向导。向导用于从用户那里获取输入。在第八章 高级服务器端开发技术中，我们将探讨如何使用这些技术进行高级用户交互。

第五章：基本服务器端开发

我们在第四章 应用模型中学习了如何在自定义模块中声明或扩展业务模型。该章节的教程中介绍了为计算字段编写方法和限制字段值的方法。本章重点介绍 Odoo 方法声明、记录集操作和扩展继承方法的服务器端编程基础。您可以使用这些知识在 Odoo 模块中创建或修改业务登录。

本章将涵盖以下教程：

指定模型方法和实现 API 装饰器
通知用户错误
为不同的模型获取一个空白记录集
创建新记录
更新记录集记录的值
搜索记录
合并记录集
过滤记录集
遍历记录集关系
排序记录集
扩展模型已建立的业务逻辑
扩展write()和create()
定制记录搜索方式
使用read_group()按组获取数据

技术要求

Odoo 的在线平台是本章的一个先决条件。

您可以从以下 GitHub 仓库获取本章中使用的所有代码：github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter05

指定模型方法和使用 API 装饰器

Odoo 模型中的类既包含业务逻辑方法，也包含字段声明。我们在第四章 应用模型中学习了如何向模型添加字段。现在我们将看到如何在模型中包含业务逻辑和方法。

在本教程中，我们将学习如何创建一个函数，该函数可能被我们的应用程序的用户界面按钮或其他代码片段使用。此方法将在HostelRoom上操作，并采取必要的步骤来修改多个房间的状态。

准备工作

本教程假设您已准备好一个实例，其中包含my_hostel附加模块，如第三章 创建 Odoo 附加模块中所述。您需要向HostelRoom模型添加一个state字段，该字段定义如下：

from odoo import api, fields, models
class HostelRoom(models.Model):
    # [...]
    state = fields.Selection([
        ('draft', 'Unavailable'),
        ('available', 'Available'),
        ('closed', 'Closed')],
        'State', default="draft")

有关更多信息，请参阅第三章 创建 Odoo 附加模块中的添加模型教程。

如何做到这一点...

要为宿舍房间定义一个方法，以更改所选房间的状态，您需要将以下代码添加到模型定义中：

添加一个辅助方法来检查状态转换是否允许：

    @api.model
    def is_allowed_transition(self, old_state, new_state):
        allowed = [('draft', 'available'),
                   ('available', 'closed'),
                   ('closed', 'draft')]
        return (old_state, new_state) in allowed

添加一个方法，将房间状态更改为通过参数传递的新状态：

    def change_state(self, new_state):
        for room in self:
            if room.is_allowed_transition(room.state,\ 
            new_state):
                room.state = new_state
            else:
                continue

添加一个方法，通过调用change_state方法来更改房间状态：

    def make_available(self):
        self.change_state('available')
    def make_closed(self):
        self.change_state('closed')

在<form>视图中添加一个按钮和状态栏。这将帮助我们通过用户界面触发这些方法：

<form>
...
    <button name="make_available" string="Make Available" type="object"/>
    <button name="make_closed" string="Make Borrowed" type="object"/>
    <field name="state" widget="statusbar"/>
...
</form>

要访问这些更新，您必须更新模块或安装它。

它是如何工作的...

教程代码中定义了几个方法。它们是典型的 Python 方法，以 self 作为它们的第一个参数，并可以选择接收额外的参数。odoo.api 模块中的 装饰器 用于装饰一些方法。

小贴士

在 Odoo 9.0 中，API 装饰器首先被添加以支持旧框架和新框架。从 Odoo 10.0 开始，之前的 API 已不再支持，然而，一些装饰器，如 @api.model，仍然在使用中。

在编写新方法时，如果您不使用装饰器，则该方法将在记录集上执行。在这样的方法中，self 是一个可以引用任意数量数据库记录的记录集（这包括空记录集），代码通常会遍历 self 中的记录以对每个单独的记录执行某些操作。

@api.model 装饰器类似，但它用于只关注模型本身的方法，而不是记录集的内容，该方法不会对记录集的内容进行操作。这个概念类似于 Python 的 @classmethod 装饰器。

在 步骤 1 中，我们创建了 is_allowed_transition() 方法。这个方法的目的在于验证从一个状态到另一个状态的转换是否有效。allowed 列表中的元组是可用的转换。例如，我们不希望允许从 closed 到 available 的转换，这就是为什么我们没有将 ('closed', 'available') 放入其中。

在 步骤 2 中，我们创建了 change_state() 方法。这个方法的目的在于改变房间的状态。当这个方法被调用时，它将根据 new_state 参数改变房间的状态。只有当转换被允许时，它才会改变房间状态。我们在这里使用了一个 for 循环，因为 self 可以包含多个记录集。

在 步骤 3 中，我们创建了通过调用 change_state() 方法来改变房间状态的方法。在我们的案例中，这个方法将由添加到用户界面的按钮触发。

在 步骤 4 中，我们在 <form> 视图中添加了 <button>。点击此按钮后，Odoo 网页客户端将调用 name 属性中提到的 Python 函数。请参考 第九章 的 添加按钮到表单 教程，了解如何从用户界面调用此类方法。我们还添加了 state 字段和 statusbar 小部件，以在 <form> 视图中显示房间的状态。

当用户从用户界面点击按钮时，将调用 步骤 3 中的某个方法。在这里，self 将是包含 hostel.room 模型记录的记录集。之后，我们调用 change_state() 方法，并根据点击的按钮传递适当的参数。

当 change_state() 被调用时，self 是 hostel.room 模型的相同记录集。change_state() 方法的主体遍历 self 以处理记录集中的每个房间。一开始在 self 上循环看起来很奇怪，但你会很快习惯这种模式。

在循环内部，change_state() 方法调用 is_allowed_transition()。调用是通过 room 本地变量进行的，但也可以对 hostel.room 模型的任何记录集进行调用，包括例如 self，因为 is_allowed_transition() 被装饰为 @api.model。如果转换被允许，change_state() 通过给记录集的属性赋值来将新状态分配给房间。这仅在长度为 1 的记录集上有效，这在遍历 self 时是保证的。

向用户报告错误

有时，在方法执行过程中停止处理是必要的，因为用户的活动无效或满足了一个错误条件。通过显示一个信息性错误消息，本教程演示了如何处理这些情况。

UserError 异常通常用于通知用户有关错误或异常情况。它通常在用户的输入未能满足预期标准或由于特定条件无法执行特定操作时使用。

准备工作

本教程要求您根据之前的说明设置一个实例，并安装了 my_hostel 扩展模块。

如何做到这一点...

我们将对前一个教程中的 change_state 方法进行修改，并在用户尝试更改 is_allowed_transition 方法不允许的状态时显示一条有用的消息。要开始，请执行以下步骤：

在 Python 文件的开头添加以下导入：

from odoo.exceptions import UserError
from odoo.tools.translate import _

修改 change_state 方法并在 else 部分抛出 UserError 异常：

def change_state(self, new_state):
    for room in self:
        if room.is_allowed_transition(room.state, new_state):
            room.state = new_state
        else:
            msg = _('Moving from %s to %s is not
allowed') % (room.state, new_state)
            raise UserError(msg)

它是如何工作的…

当 Python 中抛出异常时，它会在调用栈中向上传播，直到被处理。在 Odoo 中，响应网络客户端调用的 远程过程调用 （RPC）层会捕获所有异常，并根据异常类触发对网络客户端的不同可能行为。

在 odoo.exceptions 中未定义的任何异常都将被处理为内部服务器错误（UserError 将在用户界面中显示错误消息。教程的代码通过抛出 UserError 来确保消息以用户友好的方式显示。在所有情况下，当前数据库事务都会回滚）。

我们正在使用一个名字奇怪的函数 _()，该函数在 odoo.tools.translate 中定义。此函数用于标记字符串为可翻译的，并在运行时检索翻译字符串，给定执行上下文中找到的最终用户的语言。更多关于此的信息可以在 第十一章，国际化 中找到。

重要提示

当使用 _() 函数时，确保你只传递带有插值占位符的字符串，而不是整个插值字符串。例如，_('Warning: could not find %s') % value 是正确的，但 _('Warning: could not find %s' % value) 是错误的，因为前者不会在翻译数据库中找到替换值后的字符串。

获取不同模型的空记录集

在创建 Odoo 代码时，当前模型的方法可以通过 self 访问。通过简单地实例化其类来开始对不同的模型进行工作是不可行的；你必须首先获取该模型的记录集。

本教程向您展示如何在模型方法中为任何在 Odoo 中注册的模型获取空记录集。

准备工作

本教程将重用 my_hostel 扩展模块中库示例的设置。

我们将在 hostel.room 模型中编写一个小的方法，并搜索所有 hostel.room.members。为此，我们需要为 hostel.room.members 获取一个空记录集。确保你已经添加了 hostel.room.members 模型和该模型的访问权限。

如何操作…

要在 hostel.room 的一个方法中获取 hostel.room.members 的记录集，你需要执行以下步骤：

图 5.1 – log_all_room_members

在 HostelRoom 类中，编写一个名为 log_all_room_members 的方法：

class HostelRoom(models.Model):
    # ...
    def log_all_room_members(self):
        # This is an empty recordset of model hostel.room.member
        hostel_room_obj = self.env['hostel.room.member']
        all_members = hostel_room_obj.search([])
        print("ALL MEMBERS:", all_members)
        return True

在 <form> 视图中添加一个按钮以调用我们的方法：

<button name="log_all_room_members"  string="Log Members" type="object"/>

更新模块以应用更改。之后，你将看到 <form> 视图。你可以通过点击该按钮在服务器日志中查看成员的记录集。

它是如何工作的…

在启动时，Odoo 加载所有模块，并将从 Model 派生的各种类组合在一起，并定义或扩展给定的模型。这些类存储在任何记录集的 env 属性中，作为 self.env 可用，是 odoo.api 模块中定义的 Environment 类的实例。

Environment 类在 Odoo 开发中扮演着核心角色：

它通过模拟 Python 字典提供对注册表的快捷访问。如果你知道你要查找的模型名称，self.env[model_name] 将为你提供该模型的空记录集。此外，记录集将共享 self 的环境。
它有一个 cr 属性，这是一个你可以用来传递原始 SQL 查询的数据库游标。有关更多信息，请参阅 第八章，高级服务器端开发技术 中的 执行原始 SQL 查询 教程。
它有一个 user 属性，它是当前执行调用的用户的引用。有关更多信息，请参阅 第八章，高级服务器端开发技术 和 更改执行动作的用户 教程。
它有一个 context 属性，它是一个包含调用上下文的字典。这包括有关用户语言、时区和当前记录选择的信息。有关更多信息，请参阅 第八章，高级服务器端开发技术 中的 使用修改后的上下文调用方法 教程。

search() 调用将在后面的 搜索记录 教程中解释。

参见

有时，你可能想使用修改后的环境版本。一个例子是你可能需要一个具有不同用户和语言的环境。在 第八章，高级服务器端开发技术 中，你将学习如何在运行时修改环境。

创建新记录

在将业务逻辑流程付诸实践时，创建新记录是一个常规需求。如何为 hostel.room.category 模型构建记录包括在本教程中。我们将向 hostel.room.category 模型添加一个函数，用于生成示例目的的虚拟类别。我们将添加 <form> 视图以激活此方法。

准备工作

你需要理解你想要创建记录的模型的结构，特别是它们的名称和类型，以及这些字段上存在的任何约束（例如，是否其中一些是必填的）。

对于本教程，我们将重用第四章，应用模型中的my_hostel模块。请查看以下示例，快速回忆hostel.room.category模型：

class RoomCategory(models.Model):
    _name = 'hostel.room.category'
    _description = 'Hostel Room Category'
    name = fields.Char('Category')
    description = fields.Text('Description')
    parent_id = fields.Many2one(
        'hostel.room.category',
        string='Parent Category',
        ondelete='restrict',
        index=True
    )
    child_ids = fields.One2many(
        'hostel.room.category', 'parent_id',
        string='Child Categories')

确保你已经为hostel.room.category模型添加了菜单、视图和访问权限。

如何做到这一点…

要创建一个包含一些子类别的类别，你需要执行以下步骤：

图 5.2 – 创建类别

在hostel.room.category模型中创建一个名为create_categories的方法：
```
def create_categories(self):
    ......
```

在此方法的主体内部，为第一个子类别的字段准备一个值字典：

categ1 = {
    'name': 'Child category 1',
    'description': 'Description for child 1'
}

准备第二个类别字段的值字典：

categ2 = {
    'name': 'Child category 2',
    'description': 'Description for child 2'
}

为父类别的字段准备一个值字典：

parent_category_val = {
    'name': 'Parent category',
    'description': 'Description for parent category',
    'child_ids': [
        (0, 0, categ1),
        (0, 0, categ2),
    ]
}

调用create()方法来创建新的记录：

record = self.env['hostel.room.category'].create(parent_category_val)

在<form>视图中添加一个按钮，从用户界面触发create_categories方法：
```
<button name="create_categories" string="Create Categories" type="object"/>
```

它是如何工作的…

要为模型添加新记录，我们可以在与模型相关的任何记录集上调用create(values)方法。此方法返回一个长度为1的新记录集，其中包含具有在values字典中指定的字段值的记录。

字典中的键通过名称标识字段，而伴随的值反映了字段的值。根据字段类型，你需要为值传递不同的 Python 类型：

Text字段的值是用 Python 字符串给出的。
Float和Integer字段的值使用 Python 浮点数或整数给出。
boolean字段的值最好使用 Python 布尔值或整数给出。
Date字段的值是用 Python 的datetime.date对象给出的。
Datetime字段的值是用 Python 的datetime.datetime对象给出的。
Binary字段的值作为 Base64 编码的字符串传递。Python 标准库中的base64模块提供了如encodebytes(bytestring)等方法来对字符串进行 Base64 编码。
Many2one字段的值是用整数给出的，这个整数必须是相关记录的数据库 ID。
One2many和Many2many字段使用特殊的语法。值是一个包含三个元素元组的列表，如下所示：

表 5.1 – 关联字段写入

在本教程中，我们为想要创建的宿舍房间中的两个类别创建字典，然后我们使用这些字典在创建宿舍房间类别时，通过之前解释过的(0, 0, dict_val)语法，在child_ids条目中使用这些字典。

当在步骤 5中调用create()时，将创建三个记录：

一个用于父房间类别，由create返回
在 record.child_ids 中有两个属于儿童房间类别的记录。

还有更多…

如果模型为某些字段定义了一些默认值，则不需要进行特殊操作。create() 方法将负责计算在提供的字典中不存在的字段的默认值。

create() 方法还支持批量创建记录。要批量创建多个记录，您需要将多个值的列表传递给 create() 方法，如下例所示：

categ1 = {
    'name': 'Category 1',
    'description': 'Description for Category 1'
}
categ2 = {
    'name': 'Category 2',
    'description': 'Description for Category 2'
}
multiple_records = self.env['hostel.room.category'].create([categ1, categ2])

此代码将返回已创建的宿舍房间类别的记录集。

更新记录集记录的值

业务逻辑通常要求我们通过更改某些字段的值来更新记录。本教程展示了如何在我们进行过程中修改合作伙伴的 room_no 字段。

准备工作

本教程将使用与创建新记录教程相同的简化版 hostel.room 定义。您可以参考这个简化定义来了解字段信息。

我们在 hostel.room 模型中有一个 room_no 字段。为了说明目的，我们将通过点击按钮来写入此字段。

如何操作…

要更新房间的 room_no 字段，您可以编写一个名为 update_room_no() 的新方法，其定义如下：
```
def update_room_no(self):
    self.ensure_one()
    self.room_no = "RM002"
```
然后，您可以在 xml 中为房间的 <form> 视图添加一个按钮，如下所示：
```
<button name="update_room_no" string="Update Room No" type="object"/>
```
重新启动服务器并更新 my_hostel 模块以查看更改。点击 room_no 后，将更改房间号。

它是如何工作的…

方法首先通过调用 ensure_one() 检查作为 self 传递的房间记录集是否恰好包含一个记录。如果不是这种情况，此过程将生成异常，并停止处理。这是必要的，因为我们不希望更改多个记录的房间号。如果您想更新多个值，可以移除 ensure_one() 并使用记录集上的循环来更新属性。

最后，该方法修改房间记录的属性值。它使用定义的房间号更新 room_no 字段。只需修改记录集的字段属性，就可以执行写操作。

还有更多…

如果您想向记录的字段添加新值，有三种选择：

第一种选择是本教程中解释过的。它通过直接分配值给表示记录字段的属性来工作，在所有上下文中都有效。一次无法分配值给所有记录集元素，因此，除非您确定您只处理单个记录，否则您需要遍历记录集。
第二种选择是使用 update() 方法，通过传递字典映射字段名到您想要设置的值。这也仅适用于长度为 1 的记录集。当您需要一次性在同一记录上更新多个字段的值时，这可以节省一些打字。以下是教程的 步骤 2，重写为使用此选项：
```
def change_room_no(self):
    self.ensure_one()
    self.update({
        'room_no': "RM002",
        'another_field': 'value'
        ...
    })
```
第三个选项是调用 write() 方法，传递一个将字段名映射到要设置的值的字典。此方法适用于任意大小的记录集，并且当前两个选项在每个记录和每个字段上执行一个数据库调用时，它将在单个数据库操作中更新所有具有指定值的记录。然而，它有一些限制：如果记录尚未存在于数据库中，则不起作用（有关更多信息，请参阅 第八章 中的 在更改时写入方法 教程，高级服务器端开发技术）。此外，在写入关系字段时需要特殊的格式，类似于 create() 方法使用的格式。请查看以下表格，了解用于生成关系字段不同值的格式：

表 5.2 – 关系字段更新

重要提示

1、2、3 和 5 操作类型不能与 create() 方法一起使用。

搜索记录

在业务逻辑方法中搜索记录也是一个常见的操作。有许多情况下，我们需要根据不同的标准搜索数据。本教程演示了通过名称和类别查找房间。

准备工作

本教程将使用与 创建新记录 教程相同的 hostel.room 定义。我们将在名为 find_room(self) 的方法中编写代码。

如何操作…

要查找房间，你需要执行以下步骤：

将 find_room 方法添加到 hostel.room 模型中：
```
def find_room(self):
    ...
```

为你的标准编写搜索域：

domain = [
    '|',
        '&', ('name', 'ilike', 'Room Name'),
             ('category_id.name', 'ilike', 'Category Name'),
        '&', ('name', 'ilike', 'Second Room Name 2'),
             ('category_id.name', 'ilike', 'SecondCategory Name 2')
]

使用域调用 search() 方法，这将返回记录集：
```
rooms = self.search(domain)
```

rooms 变量将包含搜索到的房间记录集。你可以打印或记录该变量，以在服务器日志中查看结果。

它是如何工作的…

第一步 定义了以 def 关键字为前缀的方法名。

第二步 在局部变量中创建一个搜索域。通常，你会在调用搜索时看到这个创建过程，但对于复杂的域，将其单独定义是一种良好的实践。

要全面了解搜索域语法，请参阅 第九章 中的 在记录列表上定义过滤器 – 域 教程，后端视图。

第三步 使用域调用 search() 方法。该方法返回一个包含所有匹配域的记录集，然后可以进一步处理。在本教程中，我们仅使用域调用该方法，但以下关键字参数也受支持：

offset=N：这用于跳过与查询匹配的前 N 条记录。这可以与 limit 一起使用来实现分页，或者在处理大量记录时减少内存消耗。默认值为 0。
limit=N：这表示最多应返回 N 条记录。默认情况下，没有限制。
order=sort_specification：此参数用于强制返回记录集中的顺序。默认情况下，顺序由模型类的_order属性决定。
count=boolean：如果为True，则返回记录数而不是记录集。默认为False。

重要提示

我们建议使用search_count(domain)方法而不是search(domain, count=True)，因为方法名称以更清晰的方式传达了行为。两者将给出相同的结果。

有时，您需要从另一个模型进行搜索，以便搜索self返回当前模型的记录集。要从另一个模型进行搜索，我们需要获取该模型的空记录集。例如，假设我们想要搜索一些联系人。为此，我们需要在res.partner模型上使用search()方法。请参考以下代码。在这里，我们获取res.partner的空记录集以搜索联系人：

def find_partner(self):
    PartnerObj = self.env['res.partner']
    domain = [
        '&', ('name', 'ilike', 'SerpentCS'),
             ('company_id.name', '=', 'SCS')
    ]
    partner = PartnerObj.search(domain)

在前面的代码中，我们在域中有两个条件。当您有两个条件进行比较时，可以省略域中的'&'，因为当您没有指定域时，Odoo 将'&'作为默认值。

还有更多...

我们之前提到，search()方法返回所有匹配域的记录。这实际上并不完全正确。安全规则确保用户只能获取他们具有read访问权限的记录。此外，如果模型有一个名为active的布尔字段，并且搜索域的任何术语都没有指定该字段的条件，那么搜索将自动添加一个隐式条件，只返回active=True的记录。因此，如果您期望搜索返回某些内容，但只得到空记录集，请确保检查active字段的值（如果存在），以检查记录规则。

请参考第八章中的调用具有不同上下文的方法教程，高级服务器端开发技术，了解如何不添加隐式的active=True条件。请查看第十章中的使用记录规则限制记录访问教程，安全访问，以获取有关记录级访问规则的信息。

如果出于某种原因，您发现自己正在编写原始 SQL 查询以查找记录 ID，确保在检索 ID 后使用self.env['record.model'].search([('id', 'in', tuple(ids))]).ids来确保应用安全规则。这在多公司Odoo 实例中尤为重要，因为记录规则用于确保公司之间的适当区分。

合并记录集

有时，您会发现您获得的记录集并不是您需要的。本教程展示了合并它们的多种方法。

准备工作

使用本教程，您需要为同一模型拥有两个或更多记录集。

如何操作...

按照以下步骤执行记录集上的常见操作：

要合并两个记录集到一个中，同时保留它们的顺序，请使用以下操作：
```
result = recordset1 + recordset2
```
要合并两个记录集到一个中，同时确保结果中没有重复，请使用以下操作：
```
result = recordset1 | recordset2
```
要找到两个记录集中共有的记录，请使用以下操作：
```
result = recordset1 & recordset2
```

它是如何工作的…

记录集类的实现为各种 Python 操作符重定义，这些操作符在此处被使用。以下是记录集上可用的最有用的 Python 操作符的总结表：

表 5.3 – 与域一起使用的操作符

此外，还有就地操作符 +=、-=、&= 和 |=，它们修改左侧操作数而不是创建一个新的记录集。这些操作符在更新记录的 One2many 或 Many2many 字段时非常有用。有关此示例，请参阅 更新记录集记录的值 教程。

过滤记录集

有时，你已经有了一个记录集，但只需要处理这些记录的子集。当然，你可以遍历记录集，每次检查条件并根据检查结果采取行动。构建仅包含感兴趣记录的新记录集以及在该记录集上使用单一操作可能更简单，在某些情况下，更有效。

本教程展示了如何使用 filter() 方法根据条件提取记录集的子集。

准备工作

我们将重用 创建新记录 教程中展示的简化 hostel.room 模型。本教程定义了一个方法，用于从提供的记录集中提取具有多个成员的房间。

如何做到这一点…

要从记录集中提取具有多个成员的记录，你需要执行以下步骤：

定义过滤记录集的方法：

       def filter_members(room):
        all_rooms = self.search([])
        filtered_rooms = self.rooms_with_multiple_members(all_rooms)

定义接受原始记录集的方法：

    @api.model
    def room_with_multiple_members(self, all_rooms):

定义一个内部 predicate 函数：

    def predicate(room):
        if len(room.member_ids) > 1:
            return True
        return False

按如下方式调用 filter()：
```
return all_room.filter (predicate)
```

此过程的输出可以打印或记录，以便服务器日志可以包含它。有关更多信息，请参阅教程的示例代码。

它是如何工作的…

由 filter() 方法实现创建的记录集是空的。这个空记录集接收所有谓词函数评估为 True 的记录。最后，返回一个新的记录集。原始记录集中的记录仍然保持相同的顺序。

在上一个教程中使用了命名内部函数。你将经常看到匿名 Lambda 函数被用于这样的简单谓词：

@api.model
def room_with_multiple_rooms(self, all_rooms):
    return all_rooms.filter(lambda b: len(b.member_ids) > 1)

实际上，你需要根据字段值在 Python 中的 truthy（非空字符串、非零数字、非空容器等）来过滤记录集。因此，如果你想过滤具有类别设置的记录，你可以像这样传递字段名进行过滤：all_rooms.filter('category_id')。

遍历记录集关系

当与长度为1的记录集一起工作时，各种字段都可作为记录属性。关系属性（One2many、Many2one和Many2many）也有值，这些值也是记录集。例如，假设我们想从hostel.room模型的记录集中访问类别名称。你可以通过以下方式通过Many2one字段的category_id遍历来访问类别名称：room.category_id.name。然而，当与包含多个记录的记录集一起工作时，不能使用属性。

本教程演示了如何使用mapped()函数导航记录集关系。我们将创建一个函数，从提供的房间列表中提取成员的名称。

准备工作

我们将重用本章中创建新记录教程中展示的hostel.room模型。

如何操作…

为了从房间记录集中检索成员名称，你必须执行以下操作：

定义一个名为get_members_names()的方法：

    @api.model
    def get_members_names(self, rooms):

调用mapped()以获取成员的联系人名称：

    return rooms.mapped('member_ids.name')

它是如何工作的…

简单定义方法是第一步。通过调用mapped(path)函数遍历记录集字段是第二步；path是一个由点分隔的字段名字符串。路由中的下一个元素应用于mapped()为路径中的每个字段创建的新记录集。这个新记录集包含通过该字段与当前记录集中的每个元素连接的所有记录。如果路由中的最后一个字段是关系字段，则mapped()返回一个记录集；否则，返回一个 Python 列表。

mapped()方法有两个有用的属性：

当路由是一个单个标量字段名时，返回的列表与处理过的记录集的时序相同
如果路由中存在关系字段，则结果顺序不保留，但会消除重复项

重要提示

当你想对self中所有记录的Many2many字段指向的所有记录执行操作时，这个第二个属性非常有用，但你需要确保操作只执行一次（即使self的两个记录共享同一个目标记录）。

排序记录集

当你使用 search() 方法获取记录集时，你可以传递一个可选的排序参数来获取特定顺序的记录集。如果你已经从一个之前的代码段中获取了一个记录集并且想要对其进行排序，这将非常有用。如果你使用集合操作来合并两个记录集，例如，这可能会导致顺序丢失，这也可能很有用。

本教程将向您展示如何使用 sorted() 方法对现有记录集进行排序。我们将按评级对房间进行排序。

准备工作

我们将重用本章中在 创建新记录 教程中展示的 hostel.room 模型。

如何操作…

为了根据 rating 获取排序后的房间记录集，你需要执行以下步骤：

定义一个名为 sort_rooms_by_rating() 的方法：

    @api.model
    def sort_rooms_by_rating(self, rooms):

使用 sorted() 方法，如给定示例所示，根据 room_rating 字段对房间记录进行排序：
```
    return rooms.sorted(key='room_rating')
```

它是如何工作的…

简单定义方法是 第一步。在 第二步 中，我们使用房间的 sorted() 函数的记录集。作为键参数提供的字段将由 sorted() 函数内部获取其数据。然后，它使用 Python 的本地排序方法返回一个排序后的记录集。

它还有一个可选参数，reverse=True，它返回一个逆序的记录集。reverse 的使用方式如下：

rooms.sorted(key='room_rating', reverse=True)

扩展模型中定义的业务逻辑

将应用程序功能划分为各种模块是 Odoo 中的一种流行做法。您可以通过安装或卸载应用程序轻松实现这一点，这将启用或禁用功能。此外，当您向原始应用程序添加新功能时，您必须修改一些在原始应用程序中预定义的方法的行为。旧模型偶尔会从添加新字段中受益。这是底层框架最有用的功能之一，在 Odoo 中这个过程相当简单。

在本教程中，我们将了解如何从另一个模块中的方法扩展一个方法的方法的业务逻辑。此外，我们还将使用新模块向现有模块添加新字段。

准备工作

对于本教程，我们将继续使用上一教程中的my_hostel模块。请确保您在my_hostel模块中拥有hostel.room.category模型。

对于本教程，我们将创建一个名为my_hostel_terminate的新模块，该模块依赖于my_ hostel模块。在这个模块中，我们将管理宿舍的终止日期。我们还将根据类别自动计算退宿日期。

在第四章的如何使用继承向模型添加功能教程中，我们了解了如何向现有模型添加字段。在本模块中，我们将扩展hostel.room模型如下：

class HostelRoom(models.Model):
    _inherit = 'hostel.room'
    date_terminate = fields.Date('Date of Termination')

然后，按照以下方式扩展hostel.room.category模型：

class RoomCategory(models.Model):
    _inherit = 'hostel.room.category'
    max_allow_days = fields.Integer(
        'Maximum allows days',
        help="For how many days room can be borrowed",
        default=365)

要在视图中添加此字段，您需要遵循更改现有视图 - 视图继承教程，该教程位于第九章的后端视图部分。您可以在github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition找到完整的代码示例。

如何做到这一点…

要扩展hostel.room模型中的业务逻辑，您需要执行以下步骤：

从my_hostel_terminate模块中，我们希望在将房间状态更改为Closed时，在rooms记录中设置date_terminate。为此，我们将覆盖my_ hostel_terminate模块中的make_closed方法：

def make_closed(self):
    day_to_allocate = self.category_id.max_allow_days or 10
    self.date_return = fields.Date.today() + timedelta(days=day_to_allocate)
    return super(HostelRoom, self).make_closed()

我们还希望在房间归还并可供借用时重置date_terminate，因此我们将覆盖make_available方法来重置日期：

    def make_available(self):
        self.date_terminate = False
        return super(HostelRoom, self).make_available()

它是如何工作的…

步骤 1和步骤 2，在前一节中执行业务逻辑的扩展。我们定义了一个扩展hostel.room的模型，并重新定义了make_closed()和make_available()方法。在两个方法的最后一行，返回了父类实现的结果：

return super(HostelRoom, self).make_closed()

在 Odoo 模型的情况下，父类不是通过查看 Python 类定义所期望的。框架已经为我们记录集动态生成了一个类层次结构，父类是我们所依赖的模块中模型的定义。因此，调用 super() 会从 my_hostel 中返回 hostel.room 的实现。在这个实现中，make_closed() 将房间状态改为 Closed。因此，调用 super() 将调用父方法，并将房间状态设置为 Closed。

还有更多...

在本教程中，我们选择扩展方法的默认实现。在 make_closed() 和 make_available() 方法中，我们在 super() 调用之前修改了返回的结果。请注意，当你调用 super() 时，它将执行默认实现。当然，你还可以在 super() 调用之后执行一些操作。当然，我们也可以同时做这两件事。

然而，在方法执行过程中改变其行为更具挑战性。为了做到这一点，我们必须重构代码以提取一个扩展点到一个不同的函数，然后我们可以在扩展模块中重写这个函数。

你可能会受到重写函数的启发。始终要极端小心。如果你不使用你方法中的 super() 实现而重写函数，扩展机制以及可能扩展该方法的附加组件将会损坏，这意味着扩展方法将永远不会被调用。除非你在一个受控环境中工作，你确定安装了哪些附加组件，并且你已经验证你没有破坏它们，否则请避免这样做。另外，如果需要，请确保清楚地记录你做的所有事情。

在调用原始方法实现之前和之后你能做什么？有很多事情，包括但不限于以下内容：

改变发送给初始实现的参数（过去）
修改之前提供给原始实现的上下文
改变初始实现返回的结果（之后）
调用另一个方法（在之前和之后）
创建记录（在之前和之后）
在禁止的情况下抛出 UserError 错误以取消执行（在之前和之后）
将 self 分割成更小的记录集，并以不同的方式对每个子集调用原始实现（之前）

扩展 write() 和 create()

从本章的模型教程中扩展定义在模型中的业务逻辑展示了如何扩展定义在模型类上的方法。如果你这么想，定义在模型父类上的方法也是模型的一部分。这意味着所有定义在 models.Model（实际上，在 models.BaseModel 上，它是 models.Model 的父类）上的基方法都是可用的，并且可以被扩展。

本教程展示了如何扩展 create() 和 write() 以控制对记录某些字段的访问。

准备工作

我们将扩展来自 my_hostel 扩展模块的库示例，该模块位于 第三章，创建 Odoo 扩展模块。

将 remarks 字段添加到 hostel.room 模型中。我们只想让 Hostel Managers 组的成员能够写入该字段：

from odoo import models, api, exceptions
class HostelRoom(models.Model):
    _name = 'hostel.room'
    remarks = fields.Text('Remarks')

将 remarks 字段添加到 view/hostel_room.xml 文件的 <form> 视图中，以便从用户界面访问此字段：

<field name="remarks"/>

修改 security/ir.model.access.csv 文件以授予库用户写入权限：

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_hostel,hostel.room.user,model_hostel_room,base.group_user,1,1,0,0

如何操作...

为了防止非经理组成员修改 remarks 的值，您需要执行以下步骤：

按如下方式扩展 create() 方法：

    @api.model
    def create(self, values):
        if not self.user_has_groups('my_hostel.group_hostel_manager'):
            if values.get('remarks'):
                raise UserError(
                    'You are not allowed to modify '
                    'remarks'
                )
        return super(HostelRoom, self).create(values)

按如下方式扩展 write() 方法：

    def write(self, values):
        if not self.user_has_groups('my_hostel.group_hostel_manager'):
            if values.get('remarks'):
                raise UserError(
                    'You are not allowed to modify '
                    'manager_remarks'
                )
        return super(HostelRoom, self).write(values)

安装模块以查看代码的实际效果。现在，只有经理类型的用户可以修改 remarks 字段。为了测试此实现，您可以登录为演示用户或从当前用户撤销经理访问权限。

工作原理...

步骤 1 在上一节中重新定义了 create() 方法。在调用 create() 的基类实现之前，我们的方法使用 user_has_groups() 方法来检查用户是否属于 my_hostel.group_hostel_manager 组（这是该组的 XML ID）。如果不是这种情况，并且为 remarks 传递了值，则会引发 UserError 异常，从而阻止记录的创建。这个检查是在调用基类实现之前执行的。

步骤 2 对 write() 方法执行同样的操作。在写入之前，我们检查组和值中字段的 presence，以便在出现问题时进行写入并引发 UserError 异常。

重要提示

在网络客户端将字段设置为只读并不能阻止 RPC 调用写入它。这就是为什么我们扩展了 create() 和 write()。

在本教程中，您已经看到了如何覆盖 create() 和 write() 方法。然而，请注意，这不仅仅限于 create() 和 write() 方法。您可以覆盖任何模型方法。例如，假设您想在记录被删除时执行某些操作。为此，您需要覆盖 unlink() 方法（当记录被删除时将调用 unlink() 方法）。以下是覆盖 unlink() 方法的简短代码片段：

def unlink(self):
    # your logic
    return super(HostelRoom, self).unlink()

警告

super(…).unlink(), records would not be deleted.

自定义如何搜索记录

在第三章的定义模型表示和顺序教程中，创建 Odoo 附加模块介绍了name_get()方法，该方法用于计算记录在各种地方的表现，包括在用于在 Web 客户端显示Many2one关系的控件中。

本教程将向您展示如何通过重新定义name_search来通过房间号和名称在Many2one控件中搜索房间。

准备工作

对于这个教程，我们将使用以下模型定义：

class HostelRoom(models.Model):
    def name_get(self):
        result = []
        for room in self:
            member = room.member_ids.mapped('name')
            name = '%s (%s)' % (room.name, ', '.join(member))
            result.append((room.id, name))
            return result

当使用此模型时，Many2one控件中的房间仅通过name_search属性显示，该属性引用模型类的_rec_name属性，在我们的情况下是'name'。我们还想允许通过房间号进行过滤。

如何操作…

为了执行此教程，你需要执行以下步骤：

要能够通过房间名称、成员之一或房间号来搜索hostel.room，你需要在HostelRoom类中定义_name_search()方法，如下所示：

@api.model
def _name_search(self, name='', args=None, operator='ilike',
                  limit=100, name_get_uid=None):
     args = [] if args is None else args.copy()
     if not(name == '' and operator == 'ilike'):
         args += ['|', '|',
                  ('name', operator, name),
                  ('isbn', operator, name),
                  ('author_ids.name', operator, name)
                  ]
     return super(HostelRoom, self)._name_search(
         name=name, args=args, operator=operator,
         limit=limit, name_get_uid=name_get_uid)

在hostel.room模型中添加previous_room_id Many2one字段以测试_name_search实现：
```
previous_room = fields.Many2one('hostel.room', string='Previous Room')
```
将以下字段添加到用户界面：
```
<field name="previous_room_id" />
```
重新启动并更新模块以反映这些更改。

你可以通过在previous_room_id Many2one字段中搜索来调用_name_search方法。

它是如何工作的…

name_search()方法的默认实现实际上只调用_name_search()方法，该方法执行实际工作。此_name_search()方法有一个额外的参数，name_get_uid，用于一些边缘情况，例如如果你想要使用sudo()或不同的用户来计算结果。

我们将接收到的大多数参数不变地传递给方法的super()实现：

name是一个包含用户已输入的值的字符串。
args可以是None或用作可能记录的前过滤器的搜索域。（它可以来自Many2one关系的域参数，例如。）
operator是一个包含匹配操作符的字符串。通常，你会有'ilike'或'='。
limit是要检索的最大行数。
name_get_uid可以在调用name_get()时用来指定不同的用户，以计算在控件中显示的字符串。

我们对该方法实现的实现如下：

如果 args 是 None，则生成一个新的空列表，否则复制 args。我们复制列表是为了避免我们的修改对调用者产生副作用。
然后，我们检查 name 是否不是空字符串，或者 operator 是否不是 'ilike'。这是为了避免生成一个愚蠢的域，例如 [('name', ilike, '')]，它不会过滤任何内容。在这种情况下，我们直接跳到 super() 调用实现。
如果我们有 name，或者 operator 不是 'ilike'，那么我们将一些过滤条件添加到 args 中。在我们的例子中，我们添加了将搜索提供的名称在房间标题、房间号或成员姓名中的子句。
最后，我们调用带有修改后的域的 super() 实现并在 args 中强制 name 为 '' 和 operator 为 ilike。我们这样做是为了强制默认实现 _name_search() 不更改它接收的域，因此我们将使用我们指定的域。

参见

在 第三章 的 创建 Odoo 扩展模块 中，定义记录列表的过滤器 - 范围 教程演示了如何定义 name_get() 方法，该方法用于创建记录的文本表示。

在 第九章 的 后端视图 中的 定义记录列表的过滤器 - 范围 教程提供了更多关于搜索域语法的详细信息。

使用 `read_group()` 函数按组获取数据

在之前的教程中，我们看到了如何从数据库中搜索和获取数据。然而，有时你希望通过聚合记录来获取结果，例如上个月销售订单的平均成本。通常，我们使用 SQL 查询中的 group by 和 aggregate 函数来获取此类结果。幸运的是，在 Odoo 中，我们有 read_group() 方法。在本教程中，你将学习如何使用 read_group() 方法来获取聚合结果。

准备工作

在本教程中，我们将使用来自 第三章 的 my_hostel 扩展模块，创建 Odoo 扩展模块。

修改 hostel.room 模型，如下所示模型定义：

class HostelRoom(models.Model):
    _name = 'hostel.room'
    name = fields.Char('Name', required=True)
    cost_price = fields.Float('Room Cost')
    category_id = fields.Many2one('hostel.room.category')

添加 hostel.room.category 模型。为了简单起见，我们将其添加到相同的 hostel_room.py 文件中：

class HostelCategory(models.Model):
    _name = 'hostel.room.category'
    name = fields.Char('Category')
    description = fields.Text('Description')

我们将使用 hostel.room 模型，并获取每个类别的平均成本价格。

如何做到这一点…

要提取分组结果，我们将向 hostel.room 模型添加 _get_average_cost 方法，它将使用 read_group() 方法按组获取数据：

    @api.model
    def _get_average_cost(self):
        grouped_result = self.read_group(
            [('cost_price', "!=", False)], # Domain
            ['category_id', 'cost_price:avg'], # Fields to access
            ['category_id'] # group_by
            )
        return grouped_result

要测试此实现，你需要在用户界面中添加一个按钮来触发此方法。然后，你可以在服务器日志中打印结果。

它是如何工作的…

read_group() 方法内部使用 SQL 的 groupby 和 aggregate 函数来获取数据。传递给 read_group() 方法的最常见参数如下：

domain: 这用于过滤分组记录。有关 domain 的更多信息，请参阅 第九章 中的 搜索视图 教程，后端视图。
fields: 这个参数传递你想要与分组数据一起获取的字段名称。此参数的可能值如下：
- field name: 你可以将字段名称传递给 fields 参数，但如果你使用此选项，则必须将此字段名称传递给 groupby 参数，否则将生成错误。
- field_name:agg: 你可以使用 aggregate 函数传递字段名称。例如，在 cost_price:avg 中，avg 是一个 SQL 聚合函数。PostgreSQL 聚合函数的列表可以在 www.postgresql.org/docs/current/static/functions-aggregate.html 找到。
- name:agg(field_name): 这与之前的一个相同，但使用这种语法，你可以提供列别名，例如 average_price:avg(cost_price)。
groupby: 此参数接受一个字段描述列表。记录将根据这些字段进行分组。对于 date 和 datetime 列，你可以传递 groupby_function 来根据不同的时间间隔应用日期分组。你可以对日期类型的字段按月份进行分组。
read_group() 也支持一些可选参数，如下所示：
- offset: 这表示可选的跳过记录数。
- limit: 这表示可选的最大返回记录数。
- orderby: 如果传递此选项，则结果将根据给定的字段排序。
- lazy: 此参数接受布尔值，默认为 True。如果传递 True，则结果仅按第一个 groupby 分组，其余的 groupby 参数放在 __context 键中。如果为 False，则所有 groupby 函数在一个调用中完成。

性能提示

read_group() 比从记录集读取和处理值要快得多。因此，对于 KPI 或图表，你应该始终使用 read_group()。

第六章：管理模块数据

在 Odoo 中，管理模块数据涉及各种任务，例如在安装、升级或删除模块时在数据库中创建、更新和删除记录。这通常是通过称为数据文件的 XML 文件来完成的。

本章将研究添加组件模块在安装期间可能提供数据的情况。这有助于我们在提供元数据，如视图描述、菜单或操作，或提供默认设置时。另一个重要用途是提供演示数据，当创建数据库时，如果勾选了加载演示数据复选框，则会加载这些数据。

在本章中，我们将涵盖以下主题：

使用外部 ID 和命名空间
使用 XML 文件加载数据
使用noupdate和forcecreate标志
使用 CSV 文件加载数据
添加组件更新和数据迁移
从 XML 文件中删除记录
从 XML 文件中调用函数

技术要求

本章的技术要求包括在线 Odoo 平台。

本章中使用的所有代码都可以从以下 GitHub 仓库下载：github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter06。

为了避免重复大量代码，我们将利用在第四章、“应用模型”中定义的模型。为了遵循这些示例，请确保从Chapter05/my_hostel模块中获取my_hostel模块的代码。

使用外部 ID 和命名空间

Odoo 中的记录使用外部 ID 或 XML ID 进行标识。到目前为止，我们在本书的视图、菜单和操作等区域使用了 XML ID，但我们仍然不知道 XML ID 是什么。本食谱将为您提供更多关于它的清晰度。

如何操作...

我们将向已存在的记录中写入以演示如何使用跨模块引用：

通过注册如下数据文件来更新my_hostel模块的清单文件：
```
'data': [
'data/data.xml',
],
```

在hostel.room模型中创建一个新的房间：

<record id="hostel_room" model="hostel.room">
<field name="name"> Hostel Room 01 </field>
</record>

更改主公司的名称：

<record id="base.main_company" model="res.company">
<field name="name">Packt Publishing</field>
</record>

安装模块以应用更改。安装后，将创建Hostel Room 01房间的新记录，并将公司重命名为Packt Publishing。

它是如何工作的...

XML ID 是一个字符串，它指向数据库中的一个记录。这些 ID 本身是ir.model.data模型的记录。该模型包括诸如声明 XML ID 的模块名称、ID 字符串、引用模型和引用 ID 等信息。

每次我们在 <record> 标签上使用 XML ID 时，Odoo 都会检查字符串是否命名空间化（即是否恰好包含一个点），如果没有，它会将当前模块名称作为命名空间添加。然后，它会查找是否在 ir.model.data 中存在具有指定名称的记录。如果是，则执行列出的字段的 UPDATE 语句；如果不是，则执行 CREATE 语句。这就是你可以在记录已存在时提供部分数据的方式，就像我们之前所做的那样。

在本教程的第一个示例中，记录的 ID 是 hostel_room_1。由于它没有命名空间，最终的扩展 ID 将具有类似这样的模块名称 – my_hostel.hostel_room_1。然后，Odoo 将尝试查找 my_hostel.hostel_room_1 的记录。由于 Odoo 还没有为该扩展 ID 创建记录，它将在 hostel.room 模型中生成一个新的记录。

在第二个示例中，我们使用了主要公司的扩展 ID，即 base.main_company。正如其命名空间所暗示的，它是从基础模块加载的。由于扩展 ID 已经存在，Odoo 将执行写入（UPDATE）操作，以便公司名称更改为 Packt Publishing。

重要提示

除了更改其他模块定义的记录之外，部分数据的一个广泛应用是使用快捷元素方便地创建记录，并在该记录上写入快捷元素不支持的字段 – <act_window id="my_action" name="My action" model="res.partner" /><record id="my_action" model="ir.actions.act_window"> <field name="auto_search" eval="False" /></record>。

在 Odoo 中，ref 函数用于在系统内部的不同记录之间建立关系。它允许你从一个记录创建到另一个记录的引用，通常使用 多对一 关系。

ref 函数，如本章“使用 XML 文件加载数据”教程中所述，如果适当，也会将当前模块作为命名空间添加，但如果结果 XML ID 已经存在，则会引发错误。这也适用于尚未命名空间的 id 属性。

如果你想查看所有外部标识符的列表，请启动开发者模式并打开设置 | 技术 | 序列与标识符 | 外部标识符 菜单。

还有更多…

你迟早需要从你的 Python 代码中访问具有 XML ID 的记录。在这些情况下，使用 self.env.ref() 函数。这返回引用记录的浏览记录（recordset）。请注意，在这里，你始终必须传递完整的 XML ID。以下是一个完整 XML ID 的示例 – <``module_name>.<record_id>.

总有一天，你可能需要使用 Python 代码来检索具有 XML ID 的记录。在这些情况下，使用 self.env.ref() 方法。这让你可以访问链接记录的浏览记录（recordset）。请注意，你必须始终在这里传递完整的 XML ID。

你可以从用户界面中看到任何记录的 XML ID。为此，你需要在 Odoo 中激活开发者模式；请参考 第一章，安装 Odoo 开发环境，以进行操作。激活开发者模式后，打开你想要查找 XML ID 的记录的表单视图。你将在顶部栏看到一个错误图标。从该菜单中，点击 查看元数据 选项。参见以下截图以供参考：

图 6.1 – 打开记录元数据的菜单

参见

咨询本章的 使用 noupdate 和 forcecreate 标志 教程，以了解为什么公司的名称仅在模块安装期间更改。

使用 XML 文件加载数据

在上一个教程中，我们使用 hostel_room_1 外部标识符创建了新的房间记录。在本教程中，我们将从 XML 文件添加不同类型的数据。我们将添加一个房间和一个作者作为演示数据。我们还将添加一个知名的出版商作为正常数据到我们的模块中。

如何操作...

按照以下步骤创建两个数据 XML 文件，并在 your__manifest__.py 文件中链接它们：

将名为 data/demo.xml 的文件添加到你的清单中，在 demo 部分：
```
'demo': [
'data/demo.xml',
],
```

将以下内容添加到该文件中：

<odoo>
<record id="member_hda" model="res.partner">
<field name="name">Husen Daudi</field>
</record>
<record id="member_jvo" model="res.partner">
<field name="name">Jay Vora</field>
</record>
<record id="hostel_room_1" model="hostel.room">
<field name="name">Hostel Room 01</field>
<field name="room_no">HR001</field>
<field name="author_ids"
eval="[(6, 0, [ref('author_hda'), ref('author_jvo')])]"
/>
</record>
</odoo>

将名为 data/data.xml 的文件添加到你的清单中，在 data 部分：
```
'data': [
'data/data.xml',
...
],
```

将以下 XML 内容添加到 data/data.xml 文件中：

<odoo>
<record id="res_partner_packt" model="res.partner">
<field name="name">Packt Publishing</field>
<field name="city">Birmingham</field>
<field name="country_id" ref="base.uk" />
</record>
</odoo>

当你现在更新你的模块时，你会看到我们创建的出版商，如果你的数据库已启用演示数据，如第三章中所述，创建 Odoo 扩展模块，你也会找到这个房间及其成员。

它是如何工作的...

数据 XML 文件使用 <record> 标签在数据库表中创建一行。<record> 标签有两个强制属性，id 和 model。对于 id 属性，请参考 使用外部 ID 和命名空间 教程；model 属性指的是模型 _name 属性。然后，我们使用 <field> 元素填充数据库中的列，正如你命名的模型所定义的那样。模型还决定哪些字段是必须填充的，并定义默认值。在这种情况下，你不需要明确为这些字段赋值。

在模块清单中注册数据 XML 文件有两种方式。第一种是使用 data 键，第二种是使用 demo 键。data 键中的 XML 文件在每次安装或更新模块时都会被加载，而带有 demo 键的 XML 文件只有在启用了数据库的演示数据时才会被加载。

在 步骤 1 中，我们在清单中注册了一个带有 demo 键的 data XML 文件。因为我们使用了 demo 键，所以只有当你为数据库启用了演示数据时，XML 文件才会被加载。

在步骤 2中，<field>元素可以包含一个简单的文本值，例如标量值的情况。如果你需要传递文件的内容（例如设置图像），请在<field>元素上使用file属性，并传递相对于附加程序路径的文件名。

要设置引用，有两种可能性。最简单的是使用ref属性，它适用于many2one字段，并且只包含要引用的记录的 XML ID。对于one2many和many2many字段，我们需要使用eval属性。在 XML 中使用eval属性来动态评估表达式。这是一个通用属性，可以用来评估 Python 代码作为字段的值。通常，<field>标签内的内容被视为字符串——例如，<field name="value">4.5</field>。这将评估为字符串4.5而不是浮点数。如果你想将值评估为浮点数、布尔值或其他类型（除了字符串），你需要使用eval属性，例如<field name="value" eval="4.5" /> <field name="value" eval="False" />。

这里还有一个例子——将strftime('%Y-01-01')视为填充date字段的一种方式。X2many字段期望由一个包含三个元组的列表填充，其中元组的第一个值确定要执行的操作。在eval属性中，我们可以访问一个名为ref的函数，该函数返回作为字符串给出的 XML ID 的数据库 ID。这允许我们引用一个记录，而无需知道其具体的 ID，这个 ID 在不同的数据库中可能不同，如下所示：

(2, id, False): 这从数据库中删除了具有id的链接记录。元组的第三个元素被忽略。
(3, id, False): 这将id记录从one2many字段中分离出来。请注意，此操作不会删除记录——它只是保留现有的记录不变。元组的最后一个元素也被忽略。
(4, id, False): 这为现有的id记录添加了一个链接，元组的最后一个元素被忽略。这应该是你大多数时候使用的方法，通常伴随着ref函数来获取已知其 XML ID 的记录的数据库 ID。
(5, False, False): 这切断了所有链接，但保留了链接的记录。
(6, False, [id, ...]): 这清除当前引用的记录，用列表中提到的 ID 替换它们。元组的第二个元素被忽略。

重要提示

注意，在数据文件中顺序很重要，并且数据文件中的记录只能引用列表中先定义的数据文件中的记录。这就是为什么你应该始终检查你的模块是否可以在空数据库中安装的原因，因为在开发过程中，你经常会在各个地方添加记录，而之后定义的记录已经存在于数据库中，这是从较早的更新中来的。

演示数据总是在data键的文件之后加载，这就是为什么这个例子中的引用可以工作。

还有更多...

虽然您可以使用record元素做几乎所有事情，但有一些快捷元素使开发人员创建某些类型的记录更加方便。这些包括菜单项、模板和动作窗口。有关这些内容的更多信息，请参阅第九章，后端视图，和第十四章，CMS 网站开发。

field元素也可以包含function元素，该元素调用在模型上定义的函数以提供字段的值。请参阅从 XML 文件调用函数教程，了解我们如何简单地调用函数直接写入数据库，绕过加载机制。

前面的列表遗漏了0和1的条目，因为它们在加载数据时不是非常有用。为了完整性，它们如下所示输入：

(0, False, {'key': value})：这会创建一个引用模型的新的记录，其字段从位置三的字典中填充。元组的第二个元素被忽略。由于这些记录没有 XML ID，并且每次模块更新时都会进行评估，导致重复条目，因此最好避免这种做法。相反，应在自己的记录元素中创建记录，并如本教程中如何工作…部分所述进行链接。
(1, id, {'key': value})：这可以用来写入现有的链接记录。出于我们之前提到的原因，您应该避免在 XML 文件中使用此语法。

这些语法与我们在第五章，基本 服务器端开发中创建新记录和更新记录值教程中解释的语法相同。

使用 noupdate 和 forcecreate 标志

大多数附加模块有不同的数据类型。有些数据只需存在，模块才能正常工作，其他数据不应由用户更改，而大多数数据可以根据用户的意愿更改，并且仅作为便利提供。本教程将详细介绍如何处理不同类型。首先，我们将在已存在的记录中编写一个字段，然后我们将创建一个在模块更新期间应该被重新创建的记录。

如何做到这一点...

我们可以通过在包含的<odoo>元素或<record>元素上设置某些属性来强制执行在加载数据时从 Odoo 不同的行为：

添加一个在安装时创建但后续更新不会更新的发布者。然而，如果用户删除它，它将被重新创建：

<odoo noupdate="1">
    <record id="res_partner_packt" model="res.partner">
        <field name="name">Packt Publishing</field>
        <field name="city">Birmingham</field>
        <field name="country_id" ref="base.uk"/>
    </record>
</odoo>

添加一个room类别，在附加组件更新期间不会更改，并且如果用户删除它则不会重新创建：

<odoo noupdate="1">
    <record id="room_category_all" model="hostel.room.category"
            forcecreate="false">
        <field name="name">All rooms</field>
    </record>
</odoo>

如何工作...

<odoo>元素可以有一个noupdate属性，该属性在首次读取包含的数据记录时传播到创建的ir.model.data记录，从而成为此表中的一列。

当 Odoo 安装附加组件（称为init模式）时，无论noupdate是true还是false，都会写入所有记录。当你更新附加组件（称为update模式）时，会检查现有的 XML ID，以查看它们是否设置了noupdate标志，如果是，则忽略尝试写入此 XML ID 的元素。如果用户删除了相关的记录，则不会发生这种情况，这就是为什么你可以在update模式下通过将记录上的forcecreate标志设置为false来强制notrecreate noupdate记录。

重要提示

在旧版附加组件（包括版本 8.0 之前）中，你通常会找到一个包含<record>和其他元素的<data>元素的<openerp>元素。这仍然是可能的，但已弃用。现在，<odoo>、<openerp>和<data>具有完全相同的语义；它们被用作括号来包围 XML 数据。

参见

Odoo 还使用 XML ID 来跟踪在附加组件更新后要删除哪些数据。如果在更新之前记录具有来自模块命名空间的 XML ID，但在更新期间未重新设置 XML ID，则该记录及其 XML ID 将从数据库中删除，因为它们被认为是过时的。有关此机制的更深入讨论，请参阅附加组件更新和数据迁移教程。

使用 CSV 文件加载数据

虽然你可以使用 XML 文件完成所有需要的功能，但当需要提供大量数据时，这种格式并不方便，尤其是考虑到许多人更习惯在 Calc 或其他电子表格软件中预处理数据。CSV 格式的另一个优点是，当你使用标准的export功能时，你得到的就是 CSV 格式。在本教程中，我们将探讨如何导入类似表格的数据。

如何操作...

传统上，Odoo 中的访问控制列表（ACLs）用于管理记录和操作访问权限。ACLs 通过预定义的规则指定谁可以在指定的条目上执行特定操作（如读取、写入、创建和删除）。ACLs 通常通过 XML 文件在 Odoo 模块中定义。有关 ACLs 的更多详细信息，请参阅第十章的 ACLs 教程，安全访问。

将 security/ir.model.access.csv 添加到你的数据文件中：

'data': [
    ...
    'security/ir.model.access.csv',
],

在 ir.model.data CSV 文件中为模块添加访问安全设置：

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
access_hostel_manager,hostel.room.manager,model_hostel_room,group_hostel_manager,1,1,1,1

我们现在有一个 ACL，允许宿舍管理员读取图书记录，并且还允许他们编辑、创建或删除它们。

它是如何工作的...

你只需将所有数据文件放入你的清单的 data 列表中。Odoo 会根据文件扩展名来决定文件类型。CSV 文件的一个特点是它们的文件名必须与要导入的模型名称匹配——在我们的例子中是 ir.model.access。第一行需要是一个包含与模型字段名称完全匹配的列名的标题。

对于标量值，你可以使用带引号（如果必要，因为字符串本身包含引号或逗号）或不带引号字符串。

当使用 CSV 文件编写 many2one 字段时，Odoo 首先尝试将列值解释为 XML ID。如果没有点，Odoo 会添加当前模块名称作为命名空间，并在 ir.model.data 中查找结果。如果这失败了，就会调用模型的 name_search 函数，并将列的值作为参数传递，第一个返回的结果获胜。如果这也失败了，该行将被视为无效，Odoo 会引发错误。

添加插件更新和数据迁移

当编写插件模块时，你选择的数据库模型可能存在一些弱点，因此在插件模块的生命周期中你可能需要调整它。为了在不进行大量修改的情况下允许这样做，Odoo 支持在插件模块中进行版本控制和必要时运行迁移。

如何做到这一点...

我们假设在我们模块的早期版本中，allocation_date 字段是一个字符字段，人们可以写下他们认为合适的日期。我们现在意识到我们需要这个字段来进行比较和聚合，这就是为什么我们想将其类型更改为 Date。

Odoo 在类型转换方面做得很好，但在这个案例中，我们得自己动手，这就是为什么我们需要提供如何将安装了模块早期版本的数据库转换为当前版本可以运行的指导。让我们按照以下步骤尝试：

在你的 __manifest__.py 文件中增加版本号：
```
    'version': '17.0.2.0.1',
```

在 migrations/17.0.1.0.1/pre-migrate.py 中提供迁移前的代码：

def migrate(cr, version):
    cr.execute('ALTER TABLE hostel_room RENAME COLUMN allocation_date TO allocation_date_char')

在 migrations/17.0.1.0.1/post-migrate.py 中提供迁移后的代码：

from odoo import fields
from datetime import date
def migrate(cr, version):
    cr.execute('SELECT id, allocation_date_char FROM
    hostel_room')
    for record_id, old_date in cr.fetchall():
        # check if the field happens to be set in Odoo's
        internal
        # format
        new_date = None
        try:
            new_date = fields.Date.to_date(old_date)
        except ValueError:
            if len(old_date) == 4 and old_date.isdigit():
                # probably a year
                new_date = date(int(old_date), 1, 1)
        if new_date:
            cr.execute('UPDATE hostel_room SET allocation_date=%s WHERE id=2',
                       (new_date,))

如果没有这段代码，Odoo 会将旧的 allocation_date 列重命名为 allocation_date_moved 并创建一个新的列，因为没有从字符字段到日期字段的自动转换。从用户的角度来看，allocation_date 中的数据就消失了。

它是如何工作的...

第一个关键点是增加您附加组件的版本号，因为迁移仅在不同版本之间运行。在每次更新期间，Odoo 都会将更新时清单中的版本号写入ir_module_module表。如果版本号有三个或更少的组件，则版本号前面会加上 Odoo 的主版本和次版本。在前面的例子中，我们明确地命名了 Odoo 的主版本和次版本，这是一个好习惯，但1.0.1的值也会有相同的效果，因为内部 Odoo 会为附加组件的短版本号添加其自己的主版本和次版本号。通常，使用长表示法是一个好主意，因为您可以一眼看出附加组件是为哪个版本的 Odoo 准备的。

这两个迁移文件仅仅是代码文件，不需要在任何地方注册。当更新附加组件时，Odoo 会将ir_module_module中记录的附加组件版本与附加组件清单中的版本进行比较。如果清单的版本更高（在添加 Odoo 的主版本和次版本之后），则将在migrations文件夹中搜索，看是否包含包含版本（s）的文件夹，包括当前更新的版本。

然后，在找到的文件夹中，Odoo 会搜索以pre-开头的 Python 文件，加载它们，并期望它们定义一个名为migrate的函数，该函数有两个参数。这个函数以数据库游标作为第一个参数，当前安装的版本作为第二个参数调用。这发生在 Odoo 甚至查看附加组件定义的其余代码之前，因此您可以假设与上一个版本相比，您的数据库布局没有发生变化。

在所有pre-migrate函数成功运行之后，Odoo 会加载附加组件中声明的模型和数据，这可能会导致数据库布局发生变化。鉴于我们在pre-migrate.py中重命名了date_release，Odoo 将仅创建一个具有该名称的新列，但具有正确的数据类型。

之后，使用相同的搜索算法，将搜索并执行找到的post-migrate文件。在我们的例子中，我们需要查看每个值，看看我们是否可以从中提取出有用的东西；否则，我们将数据保留为NULL。如果不是绝对必要，不要编写遍历整个表的脚本；在这种情况下，我们会编写一个非常大、难以阅读的 SQL 开关。

重要提示

如果您只想重命名一个列，您不需要迁移脚本。在这种情况下，您可以将字段的oldname参数设置为字段的原始列名；然后 Odoo 会自行处理重命名。

还有更多...

在迁移前和迁移后的步骤中，你只能访问到一个游标，如果你习惯了 Odoo 环境，这并不太方便。在这个阶段使用模型可能会导致意外结果，因为在迁移前步骤中，附加组件的模型尚未加载，而且在迁移后步骤中，依赖于当前附加组件的附加组件定义的模型也尚未加载。然而，如果你不介意这个问题，要么是因为你想使用你的附加组件没有触及到的模型，要么是因为你知道这个问题不会成为问题，你可以通过编写以下内容来创建你习惯的环境：

from odoo import api, SUPERUSER_ID
def migrate(cr, version):
    env = api.Environment(cr, SUPERUSER_ID, {})
    # env holds all currently loaded models

参见

在编写迁移脚本时，你经常会遇到重复的任务，例如检查列或表是否存在，重命名事物，或将一些旧值映射到新值。在这里重新发明轮子既令人沮丧又容易出错；如果你能承担额外的依赖，可以考虑使用 github.com/OCA/openupgradelib。

从 XML 文件中删除记录

在之前的教程中，我们学习了如何从 XML 文件中生成或更改记录。你可能会偶尔希望删除由依赖模块创建的记录。可以使用 <delete> 标签。

准备工作

在本教程中，我们将从 XML 文件中添加一些类别，然后删除它们。在实际情况中，你将从这个模块创建此记录。但为了简单起见，我们将在同一个 XML 文件中添加一些类别，如下所示：

<record id="room_category_to_remove" model="hostel.room.category">
    <field name="name">Single sharing</field>
</record>
<record id="room_category_not_remove" model="hostel.room.category">
    <field name="name">Double Sharing</field>
</record>

如何操作...

从 XML 文件中删除记录有两种方法：

使用之前创建的记录的 XML ID：

<delete model="hostel.room.category" id="room_category_to_remove"/>

使用搜索域：

<delete model="hostel.room.category" search="[('name', 'ilike', 'Single Room Category')]"/>

它是如何工作的...

你将需要使用 <delete> 标签。要从模型中删除记录，你需要提供模型名称作为 model 属性的值。这是一个必填属性。

必须在第一种方法中提供由另一个模块的数据文件生成的记录的 XML ID。Odoo 在安装模块时会查找记录。如果指定的 XML ID 与记录匹配，则该记录将被删除；否则，将引发错误。只有从 XML 文件（或具有 XML ID 的记录）生成的记录才能被删除。

在第二种方法中，你需要通过 domain 属性传递域。在模块安装期间，Odoo 将根据此域搜索记录。如果找到记录，则将其删除。如果没有记录匹配给定的域，则此选项不会引发错误。使用此选项时要极其小心，因为它可能会删除用户的数据，因为搜索选项会删除所有匹配域的记录。

警告

<delete> 在 Odoo 中很少使用，因为它很危险。如果你不小心，可能会破坏系统。如果可能的话，尽量避免使用它。

从 XML 文件中调用函数

你可以从 XML 文件创建所有类型的记录，但有时，生成包含一些业务逻辑的数据可能很困难。你可能想在生产环境中安装依赖模块时修改记录。在这种情况下，你可以通过<function>标签调用model方法。

如何操作...

对于这个教程，我们将使用上一个教程中的代码。作为一个例子，我们将增加现有房间的价格 10 美元。请注意，你可能根据公司配置使用其他货币。

按照以下步骤从 XML 文件中调用 Python 方法：

将_update_room_price()方法添加到hostel.room模型中：

@api.model
def _update_room_price(self):
    all_rooms = self.search([])
    for room in all_rooms:
        room.cost_price += 10

将<function>添加到数据 XML 文件中：

<function model="hostel.room" name="_update_room_price"/>

它是如何工作的...

在步骤 1中，我们添加了_update_room_price()方法，该方法搜索所有书籍并将价格增加 10 美元。我们以_开始方法名，因为在 ORM 中这被认为是私有的，不能通过 RPC 调用。

在步骤 2中，我们使用了带有两个属性的<function>标签：

model：声明方法的模型名
name：你想调用的方法名

当你安装这个模块时，_update_room_price()将被调用，并且书籍的价格将增加 10 美元。

重要提示

总是使用这个功能时带上noupdate选项。否则，每次你更新你的模块时它都会被调用。

第七章：调试模块

在 第五章，基本服务器端开发，我们看到了如何编写模型方法来实现我们模块的逻辑。然而，当我们遇到错误或逻辑问题时，我们可能会陷入困境。为了解决这些错误，我们需要进行详细的检查，这可能会花费一些时间。幸运的是，Odoo 为你提供了一些调试工具，可以帮助你找到各种问题的根本原因。在本章中，我们将详细探讨各种调试工具和技术。

在本章中，我们将介绍以下食谱：

自动重新加载和 --dev 选项
生成服务器日志以帮助调试方法
使用 Odoo 壳交互式调用方法
使用 Python 调试器跟踪方法执行
理解调试模式选项

自动重新加载和 --dev 选项

在前面的章节中，我们看到了如何添加模型、字段和视图。每次我们更改 Python 文件时，我们都需要重新启动服务器以应用这些更改。如果我们更改 XML 文件，我们需要重新启动服务器并更新模块以在用户界面中反映这些更改。如果你正在开发大型应用程序，这可能会很耗时且令人沮丧。Odoo 提供了一个命令行选项 --dev 来克服这些问题。--dev 选项有几种可能的值，在本食谱中，我们将看到每个值。

准备工作

在你的开发环境中使用以下命令安装 inotify or watchdog。没有 inotify 或 watchdog，自动重新加载功能将不会工作：

$ pip3 install inotify
$ pip3 install watchdog

如何做...

要启用 dev 选项，你需要从命令行使用 --dev=value。此选项的可能值是 all、reload、pudb|wdb|ipdb|pdb、qweb、werkzeug 和 xml。查看以下食谱以获取更多信息。

它是如何工作的...

检查以下列表以了解所有 --dev 选项及其用途：

reload: 每当你对 Python 进行更改时，你需要重新启动服务器以在 Odoo 中反映这些更改。--dev=reload 选项会在你对任何 Python 文件进行更改时自动重新加载 Odoo 服务器。如果你没有安装 Python 的 inotify 包，这个功能将不会工作。当你使用此选项运行 Odoo 服务器时，你会看到这样的日志：AutoReload watcher running with inotify。
qweb: 你可以使用 QWeb 模板在 Odoo 中创建动态的网站页面。在 第十四章，CMS 网站开发，我们将看到如何使用 QWeb 模板开发网页。你可以使用 t-debug 属性在 QWeb 模板中调试问题。只有当你使用 --dev=qweb 启用 dev 模式时，t-debug 选项才会工作。
werkzeug: Odoo 使用 werkzeug 来处理 HTTP 请求。内部，Odoo 会捕获并抑制由 werkzeug 产生的所有异常。如果你使用 --dev=werkzeug，当产生异常时，werkzeug 的交互式调试器将在网页上显示。
xml: 每次你在视图结构中做出更改时，都需要重新加载服务器并更新模块以应用这些更改。使用 --dev=xml 选项，你只需从浏览器重新加载 Odoo 即可。无需重新启动服务器或更新模块。
pudb|wdb|ipdb|pdb: 你可以使用 --dev=pdb 选项，它将在 Odoo 中生成异常时激活 PDB。Odoo 支持四个 Python 调试器：pudb、wdb、ipdb 和 pdb。
all: 如果你使用 --dev=all，所有前面的选项都将被启用。

$ odoo/odoo-bin -c ~/odoo-dev/my-instance.cfg --dev=all

如果你只想启用几个选项，可以使用逗号分隔的值，如下所示：

$ odoo/odoo-bin -c ~/odoo-dev/my-instance.cfg --dev=reload,qweb

重要提示

如果你已经更改了数据库结构，例如添加了新字段，--dev=reload 选项将不会在数据库模式中反映这些更改。你需要手动更新模块；它仅适用于 Python 业务逻辑。如果你添加了新的视图或菜单，--dev=xml 选项将不会在用户界面中反映这一点。你需要手动更新模块。这在设计视图或网站页面结构时非常有用。如果用户从 GUI 中更改了视图，那么 --dev=xml 将不会从文件中加载 XML。Odoo 将使用用户更改的视图结构。

生成服务器日志以帮助调试方法

服务器日志在尝试了解崩溃前运行时发生了什么时非常有用。它们还可以添加以在调试问题时提供更多信息。这个食谱展示了如何将日志记录添加到现有方法中。

准备工作

我们将在以下方法中添加一些日志语句，该方法将产品的库存水平保存到文件中（你还需要将 product 和 stock 模块的依赖项添加到清单中）：

from os.path import join as opj
from odoo import models, api, exceptions
EXPORTS_DIR = '/srv/exports'
class ProductProduct(models.Model):
    _inherit = 'product.product'
    @api.model
    def export_stock_level(self, stock_location):
        products = self.with_context(
            location=stock_location.id
        ).search([])
        products = products.filtered('qty_available')
        fname = opj(EXPORTS_DIR, 'stock_level.txt')
        try:
            with open(fname, 'w') as fobj:
                for prod in products:
                    fobj.write('%s\t%f\n' % (prod.name,
                                             prod.qty_available))
        except IOError:
            raise exceptions.UserError('unable to save file')

如何操作...

为了在执行此方法时获取一些日志，执行以下步骤：

在代码开头，导入 logging 模块：
```
import logging
```
在模型类定义之前，为模块获取一个记录器：
```
_logger = logging.getLogger(__name__)
```

修改 export_stock_level() 方法的代码，如下所示：

@api.model
def export_stock_level(self, stock_location):
        _logger.info('export stock level for %s', stock_location.name)
        products = self.with_context(
             location=stock_location.id).search([])
        products = products.filtered('qty_available')
        _logger.debug('%d products in the location', len(products))
        fname = join(EXPORTS_DIR, 'stock_level.txt')
        try:
            with open(fname, 'w') as fobj:
                for prod in products:
                    fobj.write('%s\t%f\n' % (
                        prod.name, prod.qty_available))
        except IOError:
            _logger.exception(
                'Error while writing to %s in %s',
                'stock_level.txt', EXPORTS_DIR)
            raise exceptions.UserError('unable to save file')

它是如何工作的...

步骤 1 从 Python 标准库中导入 logging 模块。Odoo 使用此模块来管理其日志。

步骤 2 为 Python 模块设置一个记录器。我们在 Odoo 中使用常见的 __name__ 习惯用法作为记录器名称的自动变量，并通过 _logger 调用记录器。

重要提示

__name__ 变量由 Python 解释器在模块导入时自动设置，其值为模块的完整名称。由于 Odoo 对导入做了一些小技巧，附加模块在 Python 中被视为属于 odoo.addons Python 包。因此，如果食谱的代码位于 my_hostel/models/hostel.py，则 __name__ 将为 odoo.addons.my_hostel.models.hostel。

通过这样做，我们得到两个好处：

由于 logging 模块中日志记录器的层次结构，设置在 odoo 日志记录器上的全局日志配置应用于我们的日志记录器
日志将带有完整的模块路径前缀，这在尝试找到给定日志行产生的地方时非常有帮助

步骤 3 使用日志记录器生成日志消息。可用于此的方法有（按日志级别递增）% 替换和要插入到消息中的附加参数。您不需要自己处理 % 替换；如果需要生成日志，日志模块足够智能，可以执行此操作。如果您正在以 INFO 级别运行，那么 DEBUG 日志将避免替换，这将在长期运行中消耗 CPU 资源。

本食谱中展示的另一种有用方法是 _logger.exception()，它可以在异常处理程序中使用。消息将以 ERROR 级别记录，并且堆栈跟踪也会打印在应用程序日志中。

还有更多...

您可以从命令行或配置文件中控制应用程序的 日志级别。主要有两种方法来做这件事：

第一种方法是使用 --log-handler 选项。其基本语法如下：--log-handler=prefix:level。在这种情况下，前缀是日志记录器名称路径的一部分，级别是 my_hostel 日志记录器设置为 DEBUG，并为其他附加组件保留默认日志级别，你可以按照以下方式启动 Odoo：

$ python odoo.py --log-handler=odoo.addons.my_hostel:DEBUG

在命令行上可以多次指定 --log-handler。您还可以配置 odoo.service.server，我们保留信息级别消息，包括服务器启动通知：

log_handler = :ERROR,werkzeug:CRITICAL,odoo.service.server:INFO

第二种方法是使用 --log-level 选项。要全局控制日志级别，可以使用 --log-level 作为命令行选项。此选项的可能值有 critical、error、warn、debug、debug_rpc、debug_rpc_answer、debug_sql 和 test。

设置日志级别的快捷方式有一些。以下是一份列表：

--log-request 是 --log-handler=odoo.http.rpc.request:DEBUG 的快捷方式
--log-response 是 --log-handler=odoo.http.rpc.response:DEBUG 的快捷方式
--log-web 是 --log-handler=odoo.http:DEBUG 的快捷方式
--log-sql 是 --log-handler=odoo.sql_db:DEBUG 的快捷方式

使用 Odoo 壳来交互式调用方法

Odoo 网络界面是为最终用户设计的，尽管开发者模式解锁了许多强大的功能。然而，通过网络界面进行测试和调试并不是最容易的方法，因为您需要手动准备数据，在菜单中进行导航以执行操作等。Odoo 壳是一个 命令行界面，您可以使用它来发出调用。本食谱展示了如何启动 Odoo 壳并执行如调用壳内方法之类的操作。

准备工作

我们将重用之前配方中的相同代码来生成服务器日志以帮助调试方法。这允许 product.product 模型添加一个新方法。我们假设你有一个已安装并可供使用的附加组件的实例。在这个配方中，我们期望你有一个名为 project.conf 的 Odoo 配置文件。

如何做到这一点...

为了从 Odoo 壳中调用 export_stock_level() 方法，执行以下步骤：

启动 Odoo 壳并指定你的项目配置文件：

    $ ./odoo-bin shell -c project.conf --log-level=error

检查错误消息并阅读在常规 Python 命令行提示符之前显示的信息文本：

env: <odoo.api.Environment object at 0x7f48cc0868c0>
odoo: <module 'odoo' from '/home/serpentcs/workspace/17.0/odoo/__init__.py'>
openerp: <module 'odoo' from '/home/serpentcs/workspace/17.0/odoo/__init__.py'>
self: res.users(1,)
Python 3.10.13 (main, Aug 25 2023, 13:20:03) [GCC 9.4.0]
Type 'copyright', 'credits' or 'license' for more information
product.product:

product = env['product.product']

获取主要库存位置记录：

    >>> location_stock = env.ref('stock.stock_location_stock')

调用 export_stock_level() 方法：

    >>> product.export_stock_level(location_stock)

在退出前提交事务：
```
    >>> env.cr.commit()
```
通过按 Ctrl + D 退出壳。

它是如何工作的...

步骤 1 使用 odoo-bin shell 启动 Odoo 壳。所有常规命令行参数都是可用的。我们使用 -c 指定项目配置文件，并使用 --log-level 减少日志的冗余。在调试时，你可能希望为某些特定的插件设置日志级别为 DEBUG。

在提供 Python 命令行提示符之前，odoo-bin shell 启动一个不监听网络的 Odoo 实例并初始化一些全局变量，这些变量在输出中提到：

env 是一个连接到数据库的环境，并在命令行或配置文件中指定。
odoo 是为你导入的 odoo 包。你可以访问该包内的所有 Python 模块以执行你想要的操作。
openerp 是 odoo 包的别名，用于向后兼容。
self 是 res.users 的记录集，包含一个 Odoo 超用户（管理员）的单一记录，该记录与 env 环境相关联。

步骤 3 和 步骤 4 使用 env 获取一个空记录集并根据 XML ID 查找记录。步骤 5 调用 product.product 记录集上的方法。这些操作与你在方法内部使用的是相同的，唯一的区别是我们使用 env 而不是 self.env（尽管我们可以两者都有，因为它们是相同的）。有关可用的更多信息，请参阅 第五章，基本服务器端开发。

步骤 6 提交数据库事务。在这里这并不是严格必要的，因为我们没有修改数据库中的任何记录，但如果我们已经这样做并且希望这些更改持久化，这是必要的；当您通过 Web 界面使用 Odoo 时，每个 RPC 调用都在自己的数据库事务中运行，Odoo 会为您管理这些事务。当在 shell 模式下运行时，这种情况不再发生，您必须自己调用 env.cr.commit() 或 env.cr.rollback()。否则，当您退出 shell 时，任何正在进行的交易都会自动回滚。在测试时，这是可以的，但如果您使用 shell，例如，来脚本化实例的配置，别忘了提交您的工作！

还有更多...

在 shell 模式下，默认情况下，Odoo 会打开 Python 的 REPL 命令行界面。您可以使用 --shell-interface 选项使用您选择的 REPL。支持的 REPL 有 ipython、ptpython、bpython 和 python：

$ ./odoo-bin shell -c project.conf  --shell-interface=ptpython

使用 Python 调试器跟踪方法执行

有时候，应用程序日志不足以找出问题所在。幸运的是，我们还有 Python 调试器。这个食谱展示了我们如何在一个方法中插入断点并通过手动跟踪执行过程。

准备工作

我们将重用本章 使用 Odoo 命令行界面交互式调用方法 食谱中展示的 export_stock_level() 方法。请确保您手头有该方法的副本。

如何操作...

要使用 pdb 跟踪 export_stock_level() 的执行，请执行以下步骤：

编辑方法的代码，并插入此处突出显示的行：

def export_stock_level(self, stock_location):
    import pdb; pdb.set_trace()
    products = self.with_context( location=stock_location.id ).search([])
    fname = join(EXPORTS_DIR, 'stock_level.txt')
    try:
        with open(fname, 'w') as fobj:
            for prod in products.filtered('qty_available'):
                fobj.write('%s\t%f\n' % (prod.name, prod.qty_available))
    except IOError:
         raise exceptions.UserError('unable to save file')

运行该方法。我们将使用 Odoo 命令行界面，正如在 *使用 Odoo 命令行界面交互式调用方法的食谱中所述：

$ ./odoo-bin shell -c project.cfg --log-level=error
    [...]
    >>> product = env['product.product']
    >>> location_stock = env.ref('stock.stock_location_stock')
    >>> product.export_stock_level(location_stock)
    > /home/cookbook/stock_level/models.py(18)export_stock_level()
    -> products = self.with_context(
    (Pdb)

在 (Pdb) 提示符下，发出 args 命令（其快捷键为 a）以获取传递给方法的参数值：
```
(Pdb) a
self = product.product()
stock_location = stock.location(14,)
```

输入 list 命令以检查您在代码中的位置：

(Pdb) list
13       @api.model
14       def export_stock_level(self, stock_location):
15       _logger.info('export stock level for %s',
16                    stock_location.name)
17       import pdb; pdb.set_trace()
18 ->    products = self.with_context(
19       location=stock_location.id).search([])
20       products = products.filtered('qty_available')
21       _logger.debug('%d products in the location',
22                     len(products))
23       fname = join(EXPORTS_DIR, 'stock_level.txt')
(Pdb)

输入 next 命令三次以遍历方法的第一行。您也可以使用 n，这是一个快捷键：

(Pdb) next
> /home/cookbook/stock_level/models.py(19)export_stock_level()
-> location=stock_location.id).search([])
(Pdb) n
> /home/cookbook/stock_level/models.py(20)export_stock_level()
-> products = products.filtered('qty_available')
(Pdb) n
> /home/cookbook/stock_level/models.py(21)export_stock_level()
-> _logger.debug('%d products in the location',
(Pdb) n
> /home/cookbook/stock_level/models.py(22)export_stock_level()
-> len(products))
(Pdb) n
> /home/cookbook/stock_level/models.py(23)export_stock_level()
-> fname = join(EXPORTS_DIR, 'stock_level.txt')
(Pdb) n
> /home/cookbook/stock_level/models.py(24)export_stock_level()
-> try:

使用 p 命令显示 products 和 fname 变量的值：

(Pdb) p products
product.product(32, 14, 17, 19, 21, 22, 23, 29, 34, 33, 26, 27, 42)
(Pdb) p fname
'/srv/exports/stock_level.txt'

将 fname 的值更改为指向 /tmp 目录：
```
(Pdb) !fname = '/tmp/stock_level.txt'
```

使用 return（快捷键：r）命令执行当前函数：

(Pdb) return
--Return--
> /home/cookbook/stock_level/models.py(26)export_stock_level()->None
-> for product in products:

使用 cont（快捷键：c）命令恢复程序的执行：
```
(Pdb) c
>>>
```

它是如何工作的...

在 步骤 1 中，我们通过从 Python 标准库中的 pdb 模块调用 set_trace() 方法在方法的源代码中硬编码了一个断点。当此方法执行时，程序的正常流程会停止，您会得到一个 (Pdb) 提示符，您可以在其中输入 pdb 命令。

步骤 2 使用 shell 模式调用 stock_level_export() 方法。您也可以正常重启服务器并使用 Web 界面通过点击用户界面的适当元素来生成对您需要跟踪的方法的调用。

当你需要使用 Python 调试器手动逐步执行一些代码时，以下是一些会使你的生活变得更简单的提示：

将日志级别降低以避免产生过多的日志行，这会污染调试器的输出。从ERROR级别开始通常是合适的。你可能想启用一些具有更高详细度的特定日志记录器，你可以使用--log-handler命令行选项来实现（参考生成服务器日志以帮助调试方法）。
使用--workers=0运行服务器以避免任何可能导致两个不同进程两次达到相同断点的多进程问题。
使用--max-cron-threads=0运行服务器以禁用ir.cron周期性任务的处理，否则在逐步执行方法时可能会触发，这会产生不想要的日志和副作用。

步骤 3到8使用几个pdb命令来逐步执行方法的执行。以下是pdb的主要命令的摘要。其中大部分也可以使用首字母作为快捷键。我们在以下列表中通过在括号中包含可选字母来表示这一点：

h(elp): 这将显示pdb命令的帮助信息。
a(rgs): 这显示了当前函数/方法的参数值。
l(ist): 这将以 11 行为单位分块显示正在执行的源代码，最初集中在当前行。连续调用将移动到源代码文件的更远位置。你可以选择性地在开始和结束处传递两个整数，以指定要显示的区域。
p: 这将打印一个变量。
pp: 这将美化打印一个变量（对于列表和字典很有用）。
w(here): 这显示了调用堆栈，当前行在底部，Python 解释器在顶部。
u(p): 这将在调用堆栈中向上移动一级。
d(own): 这将在调用堆栈中向下移动一级。
n(ext): 这将执行当前代码行，然后停止。
s(tep): 这是为了进入方法调用的执行。
r(eturn): 这将恢复当前方法的执行，直到它返回。
c(ont(inue)): 这将恢复程序的执行，直到遇到下一个断点。
b(reak) <args>: 这将创建一个新的断点并显示其标识符；args可以是以下之一：
- <empty>: 这将列出所有断点。
- line_number: 这将在当前文件中指定的行处中断。
- filename:line_number: 这将在指定的文件中指定的行处中断（该文件将在sys.path的目录中搜索）。
- function_name: 这将在指定函数的第一行处中断。
- tbreak <args>: 这与break类似，但断点在达到后将被取消，因此后续执行该行不会触发它两次。
- disable bp_id: 这通过 ID 禁用断点。
- enable bl_id: 这通过 ID 启用已禁用的断点。
j(ump) lineno: 下一条要执行的行将是指定的行。这可以用来重新运行或跳过某些行。
(!) statement: 这将执行一个 Python 语句。如果命令看起来不像pdb命令，则可以省略!字符。例如，如果你想设置名为a的变量的值，因为a是args命令的快捷方式，你需要它。

还有更多...

在配方中，我们插入了一个pdb.set_trace()语句来中断到pdb进行调试。我们也可以直接从 Odoo shell 中启动pdb，这在无法使用pdb.runcall()轻松修改项目代码时非常有用。这个函数将方法作为第一个参数，将传递给函数的参数作为下一个参数。因此，在 Odoo shell 中，你将执行以下操作：

>>> import pdb
>>> product = env['product.product']
>>> location_stock = env.ref('stock.stock_location_stock')
>>> pdb.runcall(product.export_stock_level, location_stock)
> /home/cookbook/stock_level/models.py(16)export_stock_level()
-> products = self.with_context((Pdb)

在这个配方中，我们专注于 Python 标准库中的 Python 调试器pdb。了解这个工具非常有用，因为它保证在任何 Python 发行版中都可用。还有其他 Python 调试器可用，如ipdb(pypi.python.org/pypi/ipdb)和pudb(pypi.python.org/pypi/pudb)，它们可以用作pdb的替代品。它们共享相同的 API，并且在这个配方中看到的绝大多数命令都没有改变。当然，如果你使用 Python IDE 为 Odoo 开发，你将能够访问与之集成的调试器。

理解调试模式选项

在第一章“安装 Odoo 开发环境”中，我们看到了如何在 Odoo 中启用调试/开发者选项。这些选项在调试中非常有用，并揭示了更多技术信息。在本配方中，我们将详细查看这些选项。

如何操作...

检查第一章中“激活 Odoo 开发者工具”配方，安装 Odoo 开发环境，并激活开发者模式。激活开发者模式后，你将在顶部栏看到一个带有 bug 图标的下拉菜单，如图所示：

图 7.1 – 激活调试模式后的可用选项

在这个菜单中，你会看到各种选项。尝试它们以查看它们的作用。下一节将更详细地解释这些选项。

它是如何工作的...

让我们更深入地了解以下选项：

运行 JS 测试：此选项将带您转到 JavaScript QUnit 测试用例页面，如图下所示。它将逐个运行所有测试用例。在此，您可以查看测试用例的进度和状态。在第十八章，自动化测试用例中，我们将了解如何创建我们自己的 QUnit JavaScript 测试用例：

图 7.2 – QUnit 测试用例结果屏幕

运行 JS 移动测试：与前面的选项类似，但此选项为移动环境运行 QUnit 测试用例。
运行任何地方点击测试：此选项将逐个点击所有菜单。它将在所有视图和搜索过滤器中进行点击。如果出现问题或出现任何回归，它将显示回溯。要停止此测试，您需要重新加载页面。
打开视图：此选项将打开所有可用视图的列表。通过选择其中任何一个，您可以在不定义任何菜单或操作的情况下打开该视图。
禁用导游：Odoo 使用导游来改善新用户的入门体验。如果您想禁用它，您可以使用此选项。
开始导游：Odoo 还使用导游进行自动化测试。我们将在第十五章，Web 客户端开发中创建一个自定义入门导游。此选项将打开一个包含所有导游列表的对话框，如图下所示。通过点击导游旁边的播放按钮，Odoo 将自动执行导游的所有步骤：

图 7.3 – 手动启动导游的对话框

编辑操作：在第三章，创建 Odoo 附加模块的添加菜单项和视图配方中，我们添加了一个菜单项和一个操作来在 Odoo 中打开视图。这些操作的详细信息也存储在数据库中作为记录。此选项将打开我们打开以显示当前视图的操作的记录详情。
hostel.hostel模型，此选项将显示hostel.hostel模型字段的列表。
管理过滤器：在 Odoo 中，用户可以从搜索视图中创建自定义过滤器。此选项将打开当前模型的自定义过滤器列表。在此，您可以修改自定义过滤器。
技术翻译：此选项将打开当前模型翻译术语的列表。您可以从这里修改您模型的翻译术语。您可以参考第十一章，国际化以了解更多关于翻译的信息。
查看访问权限：此选项将显示当前模型的安全访问权限列表。
查看记录规则：此选项将显示当前模型的安全记录规则列表。
fields_view_get()方法。
ir.ui.view 记录当前视图。此选项是动态的，它将根据当前打开的视图显示选项。这意味着如果您打开看板视图，您将获得编辑视图：看板选项，如果您打开表单视图，您将获得编辑视图：****表单选项。

重要提示

您可以从编辑视图选项修改视图定义。此更新定义将适用于当前数据库，并且当您更新模块时，这些更改将被删除。因此，最好从模块中修改视图。

ir.ui.view 记录当前模型的搜索视图。
激活资产调试模式：Odoo 提供两种开发者模式：开发者模式和带资产的开发者模式。使用此选项，您可以从开发者模式切换到带资产的开发者模式。有关更多详细信息，请参阅第一章，安装 Odoo 开发环境中的激活 Odoo 开发工具配方。
激活测试资产调试模式：正如我们所知，Odoo 使用导游进行测试。启用此模式将在 Odoo 中加载测试资产。此选项将在开始****导游对话框中显示更多导游。
重新生成资产包：Odoo 通过资产包管理所有 CSS 和 JavaScript。此选项删除旧的 JavaScript 和 CSS 资产并生成新的。当您遇到由于资产缓存引起的问题时，此选项非常有用。我们将在第十四章，CMS 网站开发中了解更多关于资产包的信息。
成为超级用户：这是从版本 12 开始添加的新选项。通过激活此选项，您将切换到超级用户。即使您没有访问权限，您也可以访问记录。此选项并非对所有用户都可用；它仅适用于具有管理：设置访问权限的用户。激活此模式后，您将看到一条带条纹的顶部菜单，如图所示：

图 7.4 – 激活超级用户后的菜单

离开开发者工具：此选项允许您离开开发者模式。

我们已经看到了调试菜单下所有可用的选项。这些选项可以用于多种方式，例如调试、测试和修复问题。它们还可以用于探索视图的源代码。

第八章：高级服务器端开发技术

在第五章，基本服务器端开发中，你学习了如何为模型类编写方法，如何扩展继承模型的方法，以及如何处理记录集。本章将涉及更高级的主题，例如处理记录集的环境、在按钮点击时调用方法，以及处理onchange方法。本章中的食谱将帮助你管理更复杂的企业问题。你将学习如何通过结合视觉元素和阐明在 Odoo 应用程序开发过程中创建交互式功能的过程来建立理解。

在本章中，我们将探讨以下食谱：

更改执行操作的当前用户
以修改后的上下文调用方法
执行原始 SQL 查询
编写向导以引导用户
定义onchange方法
在服务器端调用onchange方法
使用compute方法定义onchange
基于 SQL 视图定义模型
添加自定义设置选项
实现init钩子

技术要求

对于本章，你需要 Odoo 在线平台。

本章中使用的所有代码都可以从本书的 GitHub 仓库中下载，网址为github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter08。

更改执行操作的当前用户

在编写业务逻辑代码时，你可能需要以不同的安全上下文执行一些操作。一个典型的例子是使用superuser权限执行操作，绕过安全检查。当业务需求需要操作用户没有安全访问权限的记录时，就会出现这种需求。

这个食谱将向你展示如何通过使用sudo()允许普通用户创建room记录。简单来说，我们将允许用户自己创建room，即使他们没有创建或分配room记录的权限。

准备工作

为了更容易理解，我们将添加一个新的模型来管理宿舍房间。我们将添加一个名为hostel.student的新模型。你可以参考以下定义来添加此模型：

class HostelStudent(models.Model):
   _name = "hostel.student"
   _description = "Hostel Student Information"
   name = fields.Char("Student Name")
   gender = fields.Selection([("male", "Male"),
       ("female", "Female"), ("other", "Other")],
       string="Gender", help="Student gender")
   active = fields.Boolean("Active", default=True,
       help="Activate/Deactivate hostel record")
   hostel_id = fields.Many2one("hostel.hostel", "hostel", help="Name of hostel")
   room_id = fields.Many2one("hostel.room", "Room",
       help="Select hostel room")
   status = fields.Selection([("draft", "Draft"),
       ("reservation", "Reservation"), ("pending", "Pending"),
       ("paid", "Done"),("discharge", "Discharge"), ("cancel", "Cancel")],
       string="Status", copy=False, default="draft",
       help="State of the student hostel")
   admission_date = fields.Date("Admission Date",
       help="Date of admission in hostel",
       default=fields.Datetime.today)
   discharge_date = fields.Date("Discharge Date",
       help="Date on which student discharge")
   duration = fields.Integer("Duration", compute="_compute_check_duration", inverse="_inverse_duration",
                              help="Enter duration of living")

你需要添加一个表单视图、一个动作和一个菜单项，以便从用户界面中查看这个新模型。你还需要为宿舍添加安全规则，以便它们可以发布宿舍学生。如果你不知道如何添加这些内容，请参阅第三章，创建 Odoo 附加模块。

或者，您可以使用我们从 GitHub 代码示例中提供的现成初始模块来节省时间。此模块位于Chapter08/00_initial_module文件夹中。GitHub 代码示例可在github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter08/00_initial_module找到。

如何操作...

如果你已经测试了该模块，你会发现只有具有hostel.room访问权限的用户才能将房间标记为管理员。非宿舍用户不能自己创建房间；他们需要请求管理员用户：

此用户具有宿舍管理员访问权限，这意味着他们可以创建宿舍房间记录：

图 8.1 – 此用户具有宿舍管理员访问权限

如以下截图所示，宿舍管理员也可以创建房间记录：

图 8.2 – 宿舍管理员可以创建房间记录

此用户具有宿舍用户访问权限：

图 8.3 – 此用户具有宿舍用户访问权限

他们只能看到宿舍房间记录：

图 8.4 – 宿舍用户只能看到宿舍房间记录

假设我们想要添加一个新功能，以便非宿舍用户可以自己创建房间。我们将这样做，而不会给他们hostel.room模型的访问权限。

因此，让我们学习如何让普通宿舍用户学生。

将action_assign_room()方法添加到hostel.room模型中：

class HostelStudent(models.Model):
   _name = "hostel.student"
    ...
    def action_assign_room(self):

在方法中，确保我们正在对一个单一记录进行操作：
```
self.ensure_one()
```

如果学生未付款，则发出警告（确保您已在顶部导入UserError）：

if self.status != "paid":
           raise UserError(_("You can't assign a room if it's not paid."))

以超级用户身份获取hostel.room的空记录集：
```
room_as_superuser = self.env['hostel.room'].sudo()
```

创建一个带有适当值的room记录：

room_rec = room_as_superuser.create({
           "name": "Room A-103",
           "room_no": "A-103",
           "floor_no": 1,
           "room_category_id": self.env.ref("my_hostel.single_room_categ").id,
           "hostel_id": self.hostel_id.id,
       })

要从用户界面触发此方法，请将按钮添加到学生表单视图中：

<button name="action_assign_room"
                           string="Assign Room"
                           type="object"
                           class="btn-primary"
                       />

重新启动服务器并将my_hostel更新以应用给定更改。更新后，你将在学生表单视图中看到分配房间按钮，如图所示：

图 8.5 – 学生表单视图中的分配房间按钮

当你点击它时，将创建一个新的房间记录。这对非宿舍用户也适用。你可以通过以演示用户身份访问 Odoo 来测试这一点。

工作原理...

在前三个步骤中，我们添加了一个名为action_assign_room()的新方法。当用户在学生表单视图中点击分配房间按钮时，将调用此方法。

在步骤 4中，我们使用了 sudo()。此方法返回一个新的记录集，其中包含修改后的 environment，用户在该环境中拥有 superuser 权限。当使用 sudo() 调用 recordset 时，环境将修改 environment 属性为 su，这表示环境的 superuser 状态。您可以通过 recordset.env.su 访问其状态。所有通过此 sudo 记录集进行的调用都带有超级用户权限。为了更好地理解这一点，请从方法中移除 .sudo()，然后点击 Access Error，用户将不再有权访问该模型。仅使用 sudo() 就会绕过所有安全规则。

如果您需要一个特定的用户，您可以传递一个包含该用户或该用户数据库 ID 的记录集，如下所示：

public_user = self.env.ref('base.public_user')
hostel_room = self.env['hostel.room'].with_user(public_user)
hostel_room.search([('name', 'ilike', 'Room 101')])

这段代码片段允许您使用 public 用户搜索可见的房间。

参考以下内容

查阅以下参考资料以获取更多信息：

如果您想了解更多关于环境的信息，请参阅第五章，基本 服务器端开发中的为模型获取空记录集配方。
有关访问控制列表和记录规则的更多信息，请参阅第十章，安全访问

调用一个修改过的上下文的方法

context 是记录集环境的一部分。它用于传递额外的信息，例如用户的时区和语言，从用户界面传递。你也可以使用上下文来传递动作中指定的参数。标准 Odoo 扩展中的几个方法使用上下文根据这些上下文值调整其业务逻辑。有时需要修改 recordset 中的上下文值，以从方法调用中获得所需的结果或计算字段的所需值。

这个菜谱将向你展示如何根据环境上下文中的值更改方法的行为。

准备工作

对于这个菜谱，我们将使用之前菜谱中的 my_hostel 模块。在 hostel.room 模型的表单视图中，我们将添加一个按钮来移除房间成员。如果宿舍的普通居民未经许可或授权从其分配的房间中移除其他居住者，可能会在住宿中造成混乱和问题。请注意，我们已经在房间表单视图中有了相同的按钮，但在这里，我们将探讨 Odoo 中的上下文使用，深入了解它如何影响系统操作和结果。

如何操作...

要添加一个按钮，你需要执行以下步骤：

添加 hostel.room：

<button name="action_remove_room_members"
                           string="Remove Room Members"
                           type="object"
                           class="btn-primary"
                       />

将 action_remove_room_members() 方法添加到 hostel.room 模型中：
```
def action_remove_room_members(self):
   ...
```
将以下代码添加到方法中，以更改环境上下文并调用移除房间成员的方法：
```
student.with_context(is_hostel_room=True).action_remove_room()
```

更新 hostel.student 模型的 action_remove_room() 方法，以便展示不同的行为：

def action_remove_room(self):
       if self.env.context.get("is_hostel_room"):
           self.room_id = False

它是如何工作的…

在 Odoo 中，为了修改受上下文影响的操作行为，我们做了以下操作：

确定了目标行为。
定义了上下文参数。
修改了相关的代码部分。
仔细测试了更改。
确保模块间的兼容性。

在 步骤 1 中，我们移除了房间成员。

在 步骤 2 中，我们添加了一个新的按钮，移除房间成员。用户将使用此按钮来移除成员。

在 步骤 3 和 步骤 4 中，我们添加了一个方法，当用户点击 移除房间成员 按钮时会被调用。

在 步骤 5 中，我们使用一些关键字参数调用了 student.with_context()。这返回了一个带有更新上下文的新版本的 room_id 记录集。我们在这里添加了一个键到上下文中，is_hostel_room=True，但如果你想的话，可以添加多个键。在这里我们使用了 sudo()。

在 步骤 6 中，我们检查了上下文中 is_hostel_room 键的值是否为正。

现在，当宿舍房间在学生表单视图中移除房间成员时，room 记录集为 False。

这只是一个修改过的上下文示例，但你可以使用任何方法，例如 create()、write()、unlink() 等。你也可以根据需求创建任何自定义方法。

参考信息

参考以下配方来了解 Odoo 中上下文的更多信息：

在第五章的获取空记录集的模型配方中，基本服务器端开发解释了环境是什么
在第九章的传递参数到表单和动作 – 上下文配方中，后端视图解释了如何在动作定义中修改上下文
在第五章的搜索记录配方中，基本服务器端开发解释了活动记录

执行原始 SQL 查询

大多数情况下，你可以通过使用 Odoo 的 ORM 来执行你想要的操作——例如，你可以使用search()方法来获取记录。然而，有时你需要更多；要么你不能使用域语法来表达你想要的（对于某些操作来说可能很棘手，甚至根本不可能），或者你的查询需要多次调用search()，这最终变得效率低下。

此配方展示了如何使用原始 SQL 查询来获取用户在特定房间中保存的名称和数量。

准备工作

对于这个配方，我们将使用前一个配方中的my_hostel模块。为了简单起见，我们将在日志中打印结果，但在实际场景中，你需要在你的业务逻辑中使用查询结果。在第九章的后端视图中，我们将显示此查询的结果。

如何做到这一点...

要获取用户在特定房间中保存的名称和数量信息，你需要执行以下步骤：

将action_category_with_amount()方法添加到hostel.room：
```
def action_category_with_amount(self):
    ...
```

在方法中，编写以下 SQL 查询：

"""
           SELECT
               hrc.name,
               hrc.amount
           FROM
               hostel_room AS hostel_room
           JOIN
               hostel_room_category as hrc ON hrc.id = hostel_room.room_category_id
           WHERE hostel_room.room_category_id = %(cate_id)s;""",
           {'cate_id': self.room_category_id.id}

执行查询：

self.env.cr.execute("""
           SELECT
               hrc.name,
               hrc.amount
           FROM
               hostel_room AS hostel_room
           JOIN
               hostel_room_category as hrc ON hrc.id = hostel_room.room_category_id
           WHERE hostel_room.room_category_id = %(cate_id)s;""",
           {'cate_id': self.room_category_id.id})

获取结果并记录它（确保你已经导入了logger）：

result = self.env.cr.fetchall()
       _logger.warning("Hostel Room With Amount: %s", result)

在hostel.room模式的表单视图中添加一个按钮来触发我们的方法：

<button name="action_category_with_amount"
                           string="Log Category With Amount"
                           type="object"
                           class="btn-primary"/>

不要忘记在此文件中导入logger。然后，重新启动并更新my_hostel模块。

它是如何工作的...

在步骤 1中，我们添加了action_category_with_amount()方法，当用户点击带有金额的日志类别按钮时将被调用。

在步骤 2中，我们声明了一个 SQL SELECT查询。这将返回表示宿舍房间中数量的类别。如果你在 PostgreSQL CLI 中运行此查询，你将根据你的房间数据得到一个结果。以下是基于我的数据库的示例数据：

+---------------------------------------+-------+
| name                                  | amount|
|---------------------------------------+-------|
| Single Room                           | 3000  |
+---------------------------------------+-------+

在步骤 4中，我们在self.env.cr中存储的数据库游标上调用execute()方法。这将查询发送到 PostgreSQL 并执行它。

在 步骤 5 中，我们使用了游标的 fetchall() 方法来检索查询选择的行列表。此方法返回行列表。在我的情况下，这是 [('Single Room', 3000)]。从我们执行的查询形式来看，我们知道每一行将恰好有两个值，第一个是 name，另一个是用户在特定房间中的金额。然后，我们简单地记录下来。

在 步骤 6 中，我们添加了一个 添加 按钮来处理用户操作。

重要提示

如果你正在执行 UPDATE 查询，你需要手动使缓存无效，因为 Odoo ORM 的缓存不知道你用 UPDATE 查询所做的更改。要使缓存无效，你可以使用 self.invalidate_cache()。

还有更多...

self.env.cr 中的对象是围绕 psycopg2 游标的一个薄包装。以下是你大部分时间会想使用的方法：

execute(query, params): 这将使用在查询中标记为 %s 的参数执行 SQL 查询，其中 params 是一个元组

警告

永远不要自己进行替换；始终使用格式化选项，如 %s。如果你使用字符串连接等技术，可能会使代码容易受到 SQL 注入攻击。

fetchone(): 这将返回数据库中的一行，封装在元组中（即使查询只选择了一个列）
fetchall(): 这将返回数据库中的所有行，作为一个元组的列表
dictfetchall(): 这将返回数据库中的所有行，作为一个字典列表，映射列名到值

在处理原始 SQL 查询时要非常小心：

你正在绕过应用程序的所有安全性。确保你使用任何你检索的 ID 列表调用 search([('id', 'in', tuple(ids)]) 来过滤掉用户无权访问的记录。
你所做的任何修改都会绕过附加模块设置的约束，除了 NOT NULL、UNIQUE 和 FOREIGN KEY 约束，这些约束在数据库级别强制执行。这也适用于任何计算字段重新计算触发器，因此你可能会损坏数据库。
避免使用 INSERT/UPDATE 查询 – 通过查询插入或更新记录不会运行通过重写 create() 和 write() 方法编写的任何业务逻辑。它不会更新存储的计算字段，并且也会绕过 ORM 约束。

参见

对于访问权限管理，请参阅 第十章，安全访问。

编写向导以引导用户

在 第四章 的 使用抽象模型实现可重用模型功能 菜谱中，介绍了 models.TransientModel 基类。这个类与普通模型有很多共同之处，除了瞬态模型的记录在数据库中定期清理，因此得名瞬态。这些用于创建向导或对话框，用户在用户界面中填写，通常用于对数据库的持久记录执行操作。

准备工作

对于这个菜谱，我们将使用之前菜谱中的 my_hostel 模块。这个菜谱将添加一个新的向导。使用这个向导，用户将被分配房间。

如何做到这一点...

按照以下步骤添加一个新的向导以更新分配房间和宿舍记录：

使用以下定义向模块添加一个新的瞬态模型：

class AssignRoomStudentWizard(models.TransientModel):
   _name = 'assign.room.student.wizard'
   room_id = fields.Many2one("hostel.room", "Room", required=True)

添加执行在瞬态模型上操作的 callback 方法。将以下代码添加到 AssignRoomStudentWizard 类中：

def add_room_in_student(self):
       hostel_room_student = self.env['hostel.student'].browse(
           self.env.context.get('active_id'))
       if hostel_room_student:
           hostel_room_student.update({
               'hostel_id': self.room_id.hostel_id.id,
               'room_id': self.room_id.id,
               'admission_date': datetime.today(),
           })

为模型创建一个表单视图。将以下视图定义添加到模块视图：

<record id='assign_room_student_wizard_form' model='ir.ui.view'>
   <field name='name'>assign room student wizard form view</field>
   <field name='model'>assign.room.student.wizard</field>
   <field name='arch' type='xml'>
       <form string="Assign Room">
           <sheet>
               <group>
                   <field name='room_id'/>
               </group>
           </sheet>
           <footer>
               <button string='Update' name='add_room_in_student' class='btn-primary' type='object'/>
               <button string='Cancel' class='btn-default' special='cancel'/>
           </footer>
       </form>
   </field>
</record>

创建一个动作和一个菜单项以显示向导。将以下声明添加到模块菜单文件中：

<record model="ir.actions.act_window" id="action_assign_room_student_wizard">
   <field name="name">Assign Room</field>
   <field name="res_model">assign.room.student.wizard</field>
   <field name="view_mode">form</field>
   <field name="target">new</field>
</record>

在 ir.model.access.csv 文件中为 assign.room.student.wizard 添加访问权限：

access_assign_room_student_wizard_manager,access.assign.room.student.wizard.manager,model_assign_room_student_wizard,my_hostel.group_hostel_manager,1,1,1,1

将 my_hostel 模块更新以应用更改。

它是如何工作的...

在 第一步 中，我们定义了一个新的模型。它与其他模型没有区别，除了基类是 TransientModel 而不是 Model。TransientModel 和 Model 都有一个共同的基类，称为 BaseModel，如果您检查 Odoo 的源代码，您会看到 99% 的工作都在 BaseModel 中，而 Model 和 TransientModel 几乎都是空的。

对于 TransientModel 记录，唯一发生变化的是以下内容：

记录会定期从数据库中删除，以便瞬态模型的表不会随着时间的推移而增长
您不允许在指向普通模型的 TransientModel 实例上定义 one2many 字段，因为这将在持久模型上添加一个指向瞬态数据的列

在此情况下使用 many2many 关系。当然，如果 one2many 中的相关模型也是 TransientModel，您也可以使用 one2many 字段。

我们在模型中定义一个字段用于存储房间。我们可以添加其他标量字段，以便我们可以记录一个计划返回日期，例如。

在 第二步 中，我们向向导类中添加了代码，当在 第三步 中点击定义的按钮时将被调用。此代码读取向导的值并更新 hostel.student 记录。

在步骤 3中，我们为我们的向导定义了一个视图。有关详细信息，请参阅第九章中的文档式表单食谱，后端视图。这里的重要点是页脚中的按钮；type属性设置为'object'，这意味着当用户点击按钮时，将调用按钮的name属性指定的方法。

在步骤 4中，我们确保在我们的应用程序菜单中有一个向导的入口点。我们在动作中使用target='new'，这样表单视图就会以对话框的形式显示在当前表单之上。有关详细信息，请参阅第九章中的添加菜单项和窗口动作食谱，后端视图：

图 8.6 – 为学生分配房间的向导

在步骤 5中，我们为assign.room.student.wizard模型添加了访问权限。有了这个，管理员用户将获得对assign.room.student.wizard模型的完全权限。

注意

在 Odoo v14 之前，TransientModel不需要任何访问规则。任何人都可以创建记录，并且他们只能访问自己创建的记录。从 Odoo v14 开始，TransientModel需要访问权限。

还有更多...

这里有一些提高你的向导的技巧。

使用上下文来计算默认值

我们展示的向导需要用户在表单中填写成员的名称。我们可以使用 Web 客户端的一个功能来节省一些输入。当执行动作时，context会更新一些可以由向导使用的值：

active_model：这是与动作相关的模型名称。这通常是屏幕上显示的模型。
active_id：这表示有一个单个记录处于活动状态，并提供该记录的 ID。
active_ids：如果选择了多个记录，这将是一个包含 ID 的列表。当在树视图中选择多个项目并触发动作时会发生这种情况。在表单视图中，你得到[active_id]。
active_domain：这是向导将操作的一个附加域。

这些值可以用来计算模型的默认值，甚至可以直接用于按钮调用的方法中。为了改进本食谱中的示例，如果我们有一个在hostel.room模型表单视图中显示的按钮来启动向导，那么向导创建的上下文将包含{'active_model': 'hostel.room', 'active_id': <hostel_room_id>}。在这种情况下，你可以定义room_id字段来获取以下方法计算出的默认值：

def _default_member(self):
    if self.context.get('active_model') == 'hostel.room':
        return self.context.get('active_id', False)

向导和代码复用

在步骤 2中，我们可以在方法的开头添加self.ensure_one()，如下所示：

def add_room_in_student(self):
       hostel_room_student = self.env['hostel.student'].browse(
           self.env.context.get('active_id'))
       if hostel_room_student:
           hostel_room_student.update({
               'hostel_id': self.room_id.hostel_id.id,
               'room_id': self.room_id.id,
               'admission_date': datetime.today(),
           })

我们建议在此食谱中使用 v17。它将允许我们通过为向导创建记录并将它们放入单个记录集中来重用向导的其他部分（有关如何做到这一点，请参阅 第五章 中的 结合记录集 食谱，基本服务器端开发），然后在记录集上调用 add_room_in_student()。在这里，代码很简单，你不需要跳过所有那些环来记录不同学生分配了哪些房间。然而，在 Odoo 实例中，某些操作要复杂得多，有一个能够正确执行操作的向导总是很方便。当使用这些向导时，请确保检查源代码中任何可能的 active_model/active_id/active_ids 键的上下文使用。如果是这种情况，您需要传递一个自定义上下文（请参阅 使用修改后的上下文调用方法 食谱）。

重定向用户

步骤 2 中的方法不返回任何内容。这将在执行操作后关闭向导对话框。另一种可能性是让该方法返回一个包含 ir.action 字段的字典。在这种情况下，Web 客户端将处理操作，就像用户点击了菜单项一样。可以在 BaseModel 类中定义的 get_formview_action() 方法用来实现这一点。例如，如果我们想显示宿舍房间的表单视图，我们可以编写以下代码：

def add_room_in_student(self):
       hostel_room_student = self.env['hostel.student'].browse(
           self.env.context.get('active_id'))
       if hostel_room_student:
           hostel_room_student.update({
               'hostel_id': self.room_id.hostel_id.id,
               'room_id': self.room_id.id,
               'admission_date': datetime.today(),
           })
       rooms = self.mapped('room_id')
       action = rooms.get_formview_action()
       if len(rooms.ids) > 1:
           action['domain'] = [('id', 'in', tuple(rooms.ids))]
           action['view_mode'] = 'tree,form'
       return action

这将构建一个包含来自此向导的房间列表（实际上，当从用户界面调用向导时，将只有一个这样的房间）并创建一个动态操作，显示具有指定 ID 的房间。

重定向用户 技术可用于创建必须依次执行多个步骤的向导。向导中的每个步骤都可以通过提供一个 下一步 按钮来使用前一个步骤的值。这将调用向导上定义的方法，更新向导上的某些字段，返回一个将重新显示相同更新后的向导的操作，并为下一个步骤做好准备。

参考以下内容

请参考以下食谱以获取更多详细信息：

有关为向导定义视图的更多详细信息，请参阅 第九章 中的 文档样式表单 食谱，后端视图。
要了解有关视图和调用服务器端方法的更多信息，请参阅 第九章 中的 添加菜单项和窗口操作 食谱，后端视图。
有关为向导创建记录并将它们放入单个记录集中的更多详细信息，请参阅 第五章 中的 结合记录集 食谱，基本服务器端开发。

定义 on_change 方法

在编写业务逻辑时，通常某些字段是相互关联的。我们在第四章的向模型添加约束验证配方中探讨了如何指定字段之间的约束，应用模型。这个配方展示了一个稍微不同的概念。在这里，当用户界面中的字段被修改时，会调用onchange方法来更新客户端记录中其他字段的值，通常是在表单视图中。

我们将通过提供一个类似于在编写一个向导以引导用户配方中定义的向导来演示这一点，但可以用来记录持续时间返回。当在表单视图中设置日期时，学生的持续时间将被更新。虽然我们在Model上演示了onchange方法，但这些功能也适用于正常的Transient模型。

准备工作

对于这个配方，我们将使用本章编写一个表单以引导用户配方中的my_hostel模块。我们将创建一个宿舍学生并添加一个onchange方法，当用户选择出院日期或入院日期字段时，将自动填充持续时间。

您还希望通过定义以下模型来准备您的工作：

class HostelStudent(models.Model):
   _name = "hostel.student"
   _description = "Hostel Student Information"
   admission_date = fields.Date("Admission Date",
       help="Date of admission in hostel",
       default=fields.Datetime.today)
   discharge_date = fields.Date("Discharge Date",
       help="Date on which student discharge")
   duration = fields.Integer("Duration",          inverse="_inverse_duration",help="Enter duration of living")

最后，您需要定义一个视图。这些步骤将留作练习，由您来完成。

如何操作...

为了在用户更改时自动填充返回的持续时间，您需要在HostelStudent步骤中添加一个onchange方法，其定义如下：

   @api.onchange('admission_date', 'discharge_date')
   def onchange_duration(self):
       if self.discharge_date and self.admission_date:
           self.duration = (self.discharge_date.year - \
                           self.admission_date.year) * 12 + \
                           (self.discharge_date.month - \
                           self.admission_date.month)

它是如何工作的...

onchange方法使用@api.onchange装饰器，它传递了更改的字段名称，因此将触发对该方法的调用。在我们的情况下，我们说每当用户界面中的admission_date或discharge_date被修改时，必须调用该方法。

在方法体内，我们计算了持续时间，并使用属性赋值来更新表单视图的duration属性。

在服务器端调用`onchange`方法

onchange方法有一个限制：当你执行服务器端操作时，它不会被调用。onchange仅在通过 Odoo 用户界面执行相关操作时自动调用。然而，在几种情况下，必须调用这些onchange方法，因为它们更新了创建或更新记录中的重要字段。当然，你可以自己进行所需的计算，但这并不总是可能的，因为onchange方法可以被安装在你不知道的实例上的第三方附加模块添加或修改。

这个配方解释了如何通过手动调用在创建记录之前调用onchange方法来对一个记录调用onchange方法。

准备工作

在更改执行动作的用户配方中，我们添加了一个返回房间按钮，以便用户可以自行更新房间和宿舍。现在我们想要为返回房间和宿舍做同样的事情；我们只需使用分配房间返回向导。

如何操作...

在这个配方中，我们将手动更新hostel.room模型的记录。为此，你需要执行以下步骤：

从hostel.student.py文件中的tests实用程序导入Form：
```
from odoo.tests.common import Form
```

在hostel.room模型中创建return_room方法：

def return_room(self):
    self.ensure_one()

获取assign.room.student.wizard的空记录集：
```
wizard = self.env['assign.room.student.wizard']
```
创建一个向导Form块，如下所示：
```
with Form(wizard) as return_form:
```

通过分配房间并返回更新后的room_id值来触发onchange：

return_form.room_id = self.env.ref('my_hostel.101_room')
       record = return_form.save()                            record.with_context(active_id=self.id).add_room_in_student()

它是如何工作的...

关于步骤 1到步骤 3的解释，请参考第五章中的创建新记录配方，基本 服务器端开发。

在步骤 4中，我们创建了一个虚拟表单来处理 onchange 规范，例如 GUI。

步骤 5包含了返回房间和宿舍的完整逻辑。在第一行，我们在向导中分配了room_id。然后，我们调用了表单的save()方法，它返回了一个向导记录。之后，我们调用了add_room_in_student()方法来执行返回更新后的房间和宿舍的逻辑。

onchange方法通常从用户界面调用。但在这个配方中，我们学习了如何在服务器端使用/触发onchange方法的业务逻辑。这样，我们可以在不绕过任何业务逻辑的情况下创建记录。

参见

如果你想要了解更多关于创建和更新记录的信息，请参考第五章中的创建新记录和更新记录集记录的值配方，基本 服务器端开发。

使用计算方法定义`onchange`

在最后两个配方中，我们看到了如何定义和调用onchange方法。我们还看到了它的局限性，即它只能从用户界面自动调用。为了解决这个问题，Odoo v13 引入了一种新的定义onchange行为的方法。在这个配方中，我们将学习如何使用compute方法产生类似于onchange方法的行为。

准备工作

对于这个配方，我们将使用之前配方中的my_hostel模块。我们将用compute方法替换hostel.student的onchange方法。

如何操作...

按照以下步骤修改onchange方法以使用compute方法：

在onchange_duration()方法中将api.onchange替换为depends，如下所示：

@api.depends('admission_date', 'discharge_date')
 def onchange_duration(self):
        ...

在字段的定义中添加compute参数，如下所示：

duration = fields.Integer("Duration", compute="onchange_duration", inverse="_inverse_duration",
                              help="Enter duration of living")

升级my_hostel模块以应用代码，然后测试返回持续时间表以查看更改。

它是如何工作的...

功能上，我们的计算onchange与正常的onchange方法类似。唯一的区别是现在，onchange也会在后台更改时触发。

在步骤 1中，我们将@api.onchange替换为@api.depends。这是在字段值发生变化时重新计算方法所必需的。

在步骤 2中，我们将compute方法与字段注册。如您所注意到的，我们在compute字段定义中使用了readonly=False。默认情况下，compute方法是只读的，但通过设置readonly=False，我们确保字段是可编辑的并且可以被存储。

参考以下内容

要了解更多关于计算字段的信息，请参阅第四章中“向模型添加计算字段”的配方，应用模型。

基于 SQL 视图定义模型

当在设计一个附加模块时，我们使用类来建模数据，然后通过 Odoo 的 ORM 将它们映射到数据库表中。我们应用一些众所周知的设计原则，例如关注点分离和数据规范化。然而，在模块设计的后期阶段，从多个模型中聚合数据到一个单独的表，并在它们上面执行一些操作可能是有用的，特别是对于报告或生成仪表板。为了使这更容易，并利用 Odoo 底层PostgreSQL数据库引擎的全部功能，可以定义一个基于 PostgreSQL 视图的只读模型，而不是表。

在这个配方中，我们将重用本章中“编写向导以引导用户”配方中的房间模型，并创建一个新的模型以更容易地收集关于房间和作者的可访问性信息。

准备工作

对于这个配方，我们将使用之前配方中的my_hostel模块。我们将创建一个新的模型，名为hostel.room.availability，用于存储可用性数据。

如何操作...

要创建一个基于 PostgreSQL 视图的新模型，请按照以下步骤操作：

创建一个新的模型，将_auto类属性设置为False：

class HostelRoomAvailability(models.Model):
   _name = 'hostel.room.availability'
   _auto = False

声明您希望在模型中看到的字段，并将它们设置为readonly：

room_id = fields.Many2one('hostel.room', 'Room', readonly=True)
student_per_room = fields.Integer(string="Student Per Rooom",                   readonly=True)
availability = fields.Integer(string="Availability",readonly=True)
amount = fields.Integer(string="Amount", readonly=True)

定义init()方法以创建视图：

def init(self):
       tools.drop_view_if_exists(self.env.cr, self._table)
       query = """
       CREATE OR REPLACE VIEW hostel_room_availability AS (
       SELECT
               min(h_room.id) as id,
               h_room.id as room_id,
               h_room.student_per_room as student_per_room,
               h_room.availability as availability,
               h_room.rent_amount as amount
           FROM
               hostel_room AS h_room
           GROUP BY h_room.id
       );
       """
       self.env.cr.execute(query)

您现在可以定义新模型的视图。交叉视图特别有用于探索数据（参考第九章，后端视图）。
不要忘记为新模型定义一些访问规则（查看第十章，安全访问）。

它是如何工作的...

通常，Odoo 将使用列的字段定义为您定义的模型创建一个新的表。这是因为，在BaseModel类中，_auto属性默认为True。在步骤 1中，通过将此类属性设置为False，我们告诉 Odoo 我们将自行管理。

在步骤 2中，我们定义了一些将被 Odoo 用于生成表的字段。我们注意将它们标记为readonly=True，这样视图就不会启用您无法保存的修改，因为 PostgreSQL 视图是只读的。

在步骤 3中，我们定义了init()方法。此方法通常不执行任何操作；它在_auto_init()之后被调用（当_auto = True时负责创建表，否则不执行任何操作），我们使用它来创建一个新的 SQL 视图（或在模块升级的情况下更新现有视图）。视图创建查询必须创建一个具有与模型字段名称匹配的列名称的视图。

重要提示

忘记在视图定义查询中重命名列是一个常见的错误。这将导致当 Odoo 找不到列时出现错误消息。

注意，我们还需要提供一个名为ID的整数列值，它包含唯一的值。

还有更多...

在这样的模型上也可以有一些计算和关联字段。唯一的限制是字段不能被存储（因此，您不能使用它们来分组记录或搜索）。

如果您需要按基础用户分组，您需要通过将其添加到视图定义中来存储该字段，而不是使用相关字段。

参见

要了解更多信息，请查看以下食谱：

要了解更多关于用户操作 UI 视图的信息，请参考第九章，后端视图。
为了更好地理解访问控制和记录规则，请查看第十章，安全访问。

添加自定义设置选项

在 Odoo 中，您可以通过设置选项提供可选功能。用户可以在任何时候启用或禁用此选项。我们将在这个食谱中说明如何创建设置选项。

准备工作

在之前的食谱中，我们添加了按钮，以便宿舍用户可以点击并返回房间。并非每个宿舍都是这种情况；然而，我们将从之前的食谱创建一个my_hostel模块。

如何操作...

要创建自定义设置选项，请按照以下步骤操作：

通过继承res.config.settings模型添加新字段：

class ResConfigSettings(models.TransientModel):
   _inherit = 'res.config.settings'
   group_hostel_user = fields.Boolean(string="Hostel User", implied_group='my_hostel.group_hostel_user')

将此字段添加到现有的xpath（更多详情请参阅第九章，后端视图）：

<record id="res_config_settings_view_form" model="ir.ui.view">
       <field name="name">res.config.settings.view.form.inherit.hostel</field>
       <field name="model">res.config.settings</field>
       <field name="priority" eval="5"/>
       <field name="inherit_id" ref="base.res_config_settings_view_form"/>
       <field name="arch" type="xml">
           <xpath expr="//div[hasclass('settings')]" position="inside">
               <div class="app_settings_block" data-string="Hostel" string="Hostel" data-key="my_hostel" groups="my_hostel.group_hostel_manager">
                   <h2>Hostel</h2>
                   <div class="row mt16 o_settings_container">
                       <div class="col-12 col-lg-6 o_setting_box" id="hostel">
                           <div class="o_setting_left_pane">
                               <field name="group_hostel_user"/>
                           </div>
                           <div class="o_setting_right_pane">
                               <label for="group_hostel_user"/>
                               <div class="text-muted">
                                   Allow users to hostel user
                               </div>
                           </div>
                       </div>
                   </div>
               </div>
           </xpath>
       </field>
   </record>

添加一些操作和菜单以进行设置：

<record id="hostel_config_settings_action" model="ir.actions.act_window">
       <field name="name">Settings</field>
       <field name="type">ir.actions.act_window</field>
       <field name="res_model">res.config.settings</field>
       <field name="view_id" ref="res_config_settings_view_form"/>
       <field name="view_mode">form</field>
       <field name="target">inline</field>
       <field name="context">{'module' : 'my_hostel'}</field>
   </record>
   <menuitem name="Settings" id="hostel_setting_menu" parent="hostel_main_menu" action="hostel_config_settings_action" sequence="50"/>

重新启动服务器并更新my_hostel模块以应用更改，如下所示：

图 8.7 – 宿舍用户访问权限设置选项以启用和禁用此功能

它是如何工作的...

在 Odoo 中，所有设置选项都是在res.config.settings模型中添加的。res.config.settings是一个临时模型。在步骤 1中，我们创建了一个新的安全组。我们将使用此组来创建隐藏和显示按钮。

在步骤 2中，我们通过继承res.config.settings模型添加了一个新的布尔字段。我们添加了一个implied_group属性，其值为my_hostel.group_hostel_user。当管理员启用或禁用带有布尔字段的选项时，此组将被分配给所有odoo用户。

base.res_config_settings_view_form。

在步骤 3中，我们通过继承此设置将其添加到用户界面。我们使用xpath添加了我们的设置选项。我们将在第九章，后端视图中更详细地介绍这一点。在表定义中，您会发现此选项的属性数据键值将是您的模块名称。这仅在您在xpath中添加整个新标签时才需要。

在步骤 4中，我们添加了一个操作和一个菜单，以便从用户界面访问配置选项。您需要从操作传递{'module': 'my_hostel'}上下文，以便在点击菜单时默认打开my_hostel模块。

在步骤 5中，我们将my_hostel.group_hostel_user组添加到按钮中。由于这个组，宿舍用户和返回按钮将根据设置选项被隐藏或显示。

之后，您将看到一个单独的布尔字段来启用或禁用对所有odoo用户的implied_group。由于我们添加了组到按钮，如果用户有组，按钮将显示，如果没有组，按钮将隐藏。我们将在第十章，安全访问中详细探讨安全组。

还有更多...

有几种其他方法可以通过各种选项来管理安装或卸载。为此，您需要添加一个名为module_加上模块名称的布尔字段。例如，如果我们创建一个名为my_hostel_extras的新模块，您需要添加一个布尔字段，如下所示：

module_my_hostel_extras = fields.Boolean(
    string='Hostel Extra Features')

当您启用或禁用此选项时，odoo将安装或卸载``my_hostel_extras模块。

另一种管理设置的方法是使用系统参数。此类数据存储在ir.config_parameter模型中。以下是如何创建系统级全局参数的方法：

digest_emails = fields.Boolean(
        string="Digest Emails",
        config_parameter='digest.default_digest_emails')

字段中的config_parameter属性将确保用户数据存储在digest.default_digest_emails键中。

设置选项用于使你的应用程序通用。这些选项给用户提供了自由度，并允许他们在运行时启用或禁用功能。当你将功能转换为选项时，你可以用一个模块服务更多客户，并且你的客户可以在他们喜欢的时候启用该功能。

实现 init 钩子

在第六章 管理模块数据中，你学习了如何从 XML 或 CSV 文件中添加、更新和删除记录。然而，有时业务案例很复杂，无法使用数据文件解决。在这种情况下，你可以使用清单文件中的init钩子来执行你想要的操作。

复杂的业务案例可能需要超出标准 XML 或 CSV 文件的数据动态初始化。例如，包括与外部系统集成、执行复杂计算或根据运行时条件配置记录，这些都可以通过清单文件中的init钩子来实现。

准备工作

我们将使用之前菜谱中的相同my_hostel模块。为了简单起见，在这个菜谱中，我们只需通过post_init_hook创建一些房间记录。

如何操作...

要添加post_init_hook，请按照以下步骤操作：

使用post_init_hook键在__manifest__.py文件中注册钩子：
```
...
'post_init_hook': 'add_room_hook',
...
```

将add_room_hook()方法添加到__init__.py文件中：

from odoo import api, SUPERUSER_ID
def add_room_hook(cr, registry):
   env = api.Environment(cr, SUPERUSER_ID, {})
   room_data1 = {'name': 'Room 1', 'room_no': '01'}
   room_data2 = {'name': 'Room 2', 'room_no': '02'}
   env['hostel.room'].create([room_data1, room_data2])

它是如何工作的...

在步骤 1中，我们在清单文件中使用add_room_hook值注册了post_init_hook。这意味着在模块安装后，Odoo 将在__init__.py中查找add_room_hook方法。post_init_hook值接收环境作为参数，展示了在模块安装后执行的add_room_hook函数的实例。

在步骤 2中，我们声明了add_room_hook()方法，该方法将在模块安装后调用。我们从这个方法创建了两个记录。在实际场景中，你可以在那里编写复杂业务逻辑。

在这个例子中，我们看了post_init_hook，但 Odoo 支持另外两个钩子：

pre_init_hook：当你开始安装模块时，这个钩子将被调用。它与post_init_hook相反；它将在安装当前模块后调用：
1. 使用pre_init_hook键在__manifest__.py文件中注册钩子：
```
...
'pre_init_hook': 'pre_init_hook_hostel',
...
```

将pre_init_hook_hostel()方法添加到__init__.py文件中：

def pre_init_hook_hostel(env):
   env['ir.model.data'].search([
       ('model', 'like', 'hostel.hostel'),
   ]).unlink()

uninstall_hook：当你卸载模块时，这个钩子将被调用。这通常用于你的模块需要垃圾回收机制时：

使用uninstall_hook键在__manifest__.py文件中注册钩子：

...
'uninstall_hook': 'uninstall_hook_user',
...

将uninstall_hook_user()方法添加到__init__.py文件中：

def uninstall_hook_user(env):
   hostel = env['res.users'].search([])
   hostel.write({'active': False})

钩子是运行在现有代码之前、之后或替代现有代码的函数。钩子——以字符串形式显示的函数——包含在 Odoo 模块的__init__.py文件中。

第九章：后端视图

在所有前面的章节中，你已经看到了 Odoo 的服务器和数据库方面。在本章中，你将看到 Odoo 的用户界面（UI）方面。你将学习如何创建不同类型的视图。除了视图之外，本章还涵盖了其他组件，如操作按钮、菜单和小部件，这些将帮助你使你的应用程序更加用户友好。完成本章后，你将能够设计 Odoo 后端的 UI。请注意，本章不涵盖 Odoo 的网站部分；我们有一个单独的章节（14）来介绍这部分内容。

在本章中，我们将涵盖以下食谱：

添加菜单项和窗口操作
通过操作打开特定视图
将内容和小部件添加到表视图中
在表单中添加按钮
将参数传递给表单和操作 – 上下文
在记录列表上定义过滤器 – 域
定义列表视图
定义搜索视图
添加搜索过滤器侧边栏
修改现有视图 – 视图继承
定义文档样式表单
使用属性动态表单元素
定义嵌入式视图
在表视图的侧边显示附件
定义看板视图
根据其状态在列中显示看板卡片
定义日历视图
定义图形视图和交叉视图
定义群体视图
定义甘特图视图
定义活动视图
定义地图视图

技术要求

在本章的整个过程中，我们将假设你有一个安装了基本附加组件的数据库和一个空的 Odoo 附加模块，你可以将食谱中的 XML 代码添加到附加模块清单中引用的数据文件中。有关如何在你的附加组件中激活更改的更多信息，请参阅第三章，创建 Odoo 附加模块。

本章的技术要求包括一个在线 Odoo 平台。

本章中使用的所有代码都可以从 GitHub 存储库中下载，网址为github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter09。

添加菜单项和窗口操作

向用户提供新功能的明显方式是通过添加菜单项。当你点击一个菜单项时，会发生某些事情。这个食谱将指导你如何定义这件事。

我们将创建一个顶级菜单及其子菜单，该菜单将打开所有宿舍房间列表。

这也可以通过Web 用户界面通过设置菜单来完成，但我们更喜欢使用 XML 数据文件，因为这是我们创建我们的附加模块时必须使用的。

准备工作

在这个菜谱中，我们需要一个依赖于base模块的模块，因为my_hostel模块向hostel.room添加了新的模型。所以，如果你正在使用现有的模块，请在清单中添加base依赖。或者，你可以从github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter09/00_initial_module获取初始模块。

如何操作...

在我们的附加模块的 XML 数据文件中执行以下步骤：

定义要执行的操作：

<record id="action_hostel_room" model="ir.actions.act_window">
    <field name="name">All Hostel Room</field>
    <field name="res_model">hostel.room</field>
    <field name="view_mode">tree,form</field>
</record>

创建顶级菜单，如下所示：

    <menuitem id="menu_custom_hostel_room"
    name="Hostel Room" web_icon="my_hostel,static/description/icon.png"/>

在菜单中引用我们的操作：

<menuitem id="menu_all_hostel_room"
    parent="menu_custom_hostel_room" action="action_hostel_room"       sequence="10" groups="" />

如果我们现在升级模块，我们将看到一个带有Hostel Room标签的顶级菜单，它打开一个名为All Hostel Room的子菜单。点击该菜单项将打开所有宿舍房间的列表。

它是如何工作的...

第一个 XML 元素record model="ir.actions.act_window"声明了一个窗口操作，用于显示包含所有宿舍房间的列表视图。我们使用了最重要的属性：

name: 用来作为由动作打开的视图的标题。
res_model：这是要使用的模型。我们使用hostel.room，这是 Odoo 存储所有hostel room的地方。
view_mode：这列出了要提供的视图类型。它是一个以逗号分隔的视图类型文件。默认值是tree, form，这使得列表视图和表单视图可用。如果你只想显示日历和表单视图，那么view_mode的值应该是calendar, form。其他可能的视图选择是kanban、graph、pivot、calendar和cohort。你将在接下来的菜谱中了解更多关于这些视图的信息。
domain: 这是可选的，允许你设置一个过滤器，以在视图中提供可用的记录。我们将在本章的在记录列表上定义过滤器 – Domain菜谱中更详细地了解所有这些视图。
context: 这可以设置提供给打开的视图的值，影响它们的行为。在我们的例子中，对于新记录，我们希望房间等级的默认值为1。这将在本章的向表单和动作传递参数 – Context菜谱中更深入地讨论。
limit：这设置了在列表视图中可以看到的默认记录数量。在我们的例子中，我们给出了20的限制，但如果你不提供limit值，Odoo 将使用默认值80。

接下来，我们从顶级菜单创建到可点击的末级菜单项的菜单项层次结构。menuitem元素最重要的属性如下：

name：这用于显示菜单项的文本。如果你的菜单项链接到操作，你可以省略它，因为在这种情况下将使用操作名称。
parent (parent_id如果使用record元素)：这是引用父菜单项的 XML ID。没有父项的项目是顶级菜单。
action: 这是引用要调用的操作的 XML ID。
sequence: 这用于对同级菜单项进行排序。
groups (groups_id与record标签): 这是一个可选的用户组列表，可以访问菜单项。如果为空，则对所有用户可用。
web_icon: 此选项仅在顶级菜单上工作。它将在企业版中显示您的应用程序的图标。

窗口操作会自动确定要使用的视图，通过查找目标模型的视图（form、tree等）并选择序列号最低的一个。ir.actions.act_window和menuitem是方便的快捷 XML 标签，隐藏了您实际正在做的事情。如果您不想使用快捷 XML 标签，则可以通过<record>标签创建ir.actions.act_window和ir.ui.menu模型的记录。例如，如果您想通过<record>加载act_window，可以这样做：

<record id="action_hostel_room" model="ir.actions.act_window">
    <field name="name">All Hostel Room</field>
    <field name="res_model">hostel.room</field>
    <field name="view_mode">tree,form</field>
    <field name="context">{'default_room_rating': 1.0}</field>
    <field name="domain">[('state', '=', 'draft')]</field>
</record>

以同样的方式，您可以通过<record>创建一个menuitem实例。

重要提示

注意，使用menuitem快捷方式时使用的名称可能不会映射到使用record元素时使用的字段名称；parent应该是parent_id，而groups应该是groups_id。

为了构建菜单，Web 客户端读取ir.ui.menu中的所有记录，并从parent_id字段推断它们的层次结构。菜单也会根据用户对模型和分配给菜单和操作的组的权限进行过滤。当用户点击菜单项时，其action将被执行。

还有更多...

窗口操作还支持一个target属性来指定视图的展示方式。可能的选项如下：

current: 这是默认选项，在 Web 客户端的主要内容区域打开视图。
new: 这将在弹出窗口中打开视图。
current,但它以编辑模式打开表单并禁用操作菜单。
全屏: 该操作将覆盖整个浏览器窗口，因此也会覆盖菜单。有时，这被称为平板模式。
main: 这类似于current，但它还会清除面包屑。

对于窗口操作，还有一些额外的属性，这些属性不支持ir.actions.act_window快捷标签。要使用它们，我们必须使用具有以下字段的record元素：

res_id: 如果打开表单，您可以通过在此处设置其 ID 来打开特定的记录。这在多步骤向导或您需要频繁查看或编辑特定记录的情况下非常有用。
search_view_id: 这指定了用于树形视图和图形视图的特定搜索视图。

请记住，左上角的菜单（或企业版本中的应用程序图标）和顶部栏中的菜单都是由菜单项组成的。唯一的区别是左上角的菜单项没有父菜单，而顶部栏上的菜单项以顶部栏中的相应菜单项作为父菜单。在左侧栏中，层次结构更为明显。

此外，请记住，出于设计原因，如果您的二级菜单有子菜单，则一级菜单将打开下拉菜单。在任何情况下，Odoo 都将根据子菜单项的顺序打开第一个菜单项的动作。

参考以下内容以了解更多关于菜单和视图的信息：

ir.actions.act_window动作类型是最常见的动作类型，但菜单可以引用任何类型的动作。技术上，如果你链接到客户端动作、服务器动作或ir.actions.*命名空间中定义的任何其他模型，都是相同的。它只是在后端对动作的处理上有所不同。
如果你只需要在具体要调用的动作中获得一点更多的灵活性，请查看返回窗口动作的服务器动作。如果你需要完全的灵活性，请查看客户端动作（ir.actions.client），它允许你拥有完全定制的用户界面。然而，只有作为最后的手段才这样做，因为当你使用它们时，你会失去 Odoo 的许多方便的助手。

参见

要详细了解所有视图中的过滤器，请参阅本章中的在记录列表上定义过滤器 – 域配方。

通过动作打开特定视图

窗口动作会自动确定要使用的视图，如果没有给出，但有时我们希望动作打开一个特定的视图。

我们将为hostel.room模型创建一个基本表单视图，然后我们将创建一个新的窗口动作，专门用于打开该表单视图。

如何操作...

定义hostel room的最小树形和表单视图：

<record id="hostel_room_view_tree" model="ir.ui.view">
    <field name="name">Hostel Room List</field>
    <field name="model">hostel.room</field>
<field name="arch" type="xml">
        <tree>
        <field name="name"/>
            <field name="room_no"/>
            <field name="state"/>
        </tree>
    </field>
</record>
<record id="hostel_room_view_form" model="ir.ui.view">
    <field name="name">Hostel Room Form</field>
    <field name="model">hostel.room</field>
<field name="arch" type="xml">
        <form>
            <header>
                <button name="make_available" string="Make Available" type="object"/>
                <button name="make_closed"  string="Make Closed" type="object"/>
                <field name="state" widget="statusbar"/>
            </header>
            <group>
                <group>
<field name="name"/>
                    <field name="room_no"/>
                </group>
                <group>
                    <field name="description"/>
                </group>
            </group>
        </form>
    </field>
</record>

将从添加菜单项和窗口动作配方中的动作更新为使用新的表单视图：

<record id="action_hostel_room_tree" model="ir.actions.act_window.view">
    <field name="act_window_id" ref="action_hostel_room" />
    <field name="view_id" ref="hostel_room_view_tree" />
    <field name="view_mode">tree</field>
    <field name="sequence" eval="1"/>
</record>
<record id="action_hostel_room_form" model="ir.actions.act_window.view">
    <field name="act_window_id" ref="action_hostel_room" />
    <field name="view_id" ref="hostel_room_view_form" />
    <field name="view_mode">form</field>
    <field name="sequence" eval="2"/>
</record>

现在，如果你打开你的菜单并点击列表中的合作伙伴，你应该看到我们刚刚定义的非常简单的表单和树形视图。

它是如何工作的...

这次，我们使用了适用于任何类型记录的通用 XML 代码，即具有所需id和model属性的record元素。record元素上的id属性是一个任意字符串，它必须对于你的附加组件是唯一的。model属性指的是你想要创建的模型名称。鉴于我们想要创建一个视图，我们需要创建ir.ui.view模型的记录。在此元素内，你通过model属性设置模型中定义的字段。对于ir.ui.view，关键字段是model和arch。model字段包含你想要定义视图的模型，而arch字段包含视图本身的定义。我们稍后会介绍其内容。

name字段虽然不是必需的，但在调试视图问题时很有帮助。因此，将其设置为字符串，说明这个视图打算做什么。此字段的内容不会显示给用户，因此你可以填写任何你认为合理的技术提示。如果你在这里不设置任何内容，你将获得一个默认名称，其中包含模型名称和视图类型。

ir.actions.act_window.view

我们定义的第二个记录与我们在添加菜单项和窗口动作菜谱中定义的act_window协同工作。我们已经知道，通过设置那里的view_id字段，我们可以选择用于第一个视图模式哪个视图。然而，鉴于我们设置了view_mode字段为tree, form视图，view_id必须选择树视图，但我们想设置的是第二个的表单视图。

如果你发现自己处于这种情况，请使用ir.actions.act_window.view模型，它允许你精细控制为哪种视图类型加载哪些视图。这里定义的前两个字段是引用其他对象的通用方式的示例；你保持元素的主体为空，但添加一个名为ref的属性，其中包含你要引用的对象的 XML ID。因此，这里发生的情况是我们从上一个菜谱中的act_window_id字段引用我们的动作，并在view_id字段中引用我们刚刚创建的视图。然后，尽管不是必需的，我们添加一个序列号来定位这个视图分配相对于同一动作的其他视图分配的位置。这仅在你通过创建多个ir.actions.act_window.view记录为不同的视图模式分配视图时才有意义。

重要提示

一旦你定义了ir.actions.act_window.view记录，它们将优先于你在动作的view_mode字段中填写的内容。因此，使用前面的记录，你将看不到任何列表，而只有表单。你应该添加另一个指向hostel.room模型列表视图的ir.actions.act_window.view记录。

在表单视图中添加内容和小部件

前面的菜谱展示了如何为动作选择特定的视图。现在，我们将演示如何使表单视图更有用。在这个菜谱中，我们将使用我们在有一个动作打开特定视图菜谱中定义的表单视图。在表单视图中，我们将添加小部件和内容。

如何操作...

定义表单视图的基本结构：

<record id="hostel_room_view_form" model="ir.ui.view">
    <field name="name">Hostel Room Form</field>
    <field name="model">hostel.room</field>
    <field name="arch" type="xml">
    <form>
        <!--form content goes here -->
    </form>
</record>

要添加标题栏，通常用于动作按钮和阶段流程，请在表单内添加以下内容：

<header>
    <button name="make_available" string="Make Available" type="object"/>
    <button name="make_closed"  string="Make Closed" type="object"/>
    <field name="state" widget="statusbar"/>
</header>

使用group标签组织表单字段：

<group string="Content" name="my_content">
    <field name="name"/>
    <field name="room_no"/>
</group>
<group>
    <field name="description"/>
</group>
<notebook>
    <page string="Other Information" name="other_information">
        <field name="other_info" widget="html"/>
    </page>
</notebook>

现在，表单应该显示一个带有按钮和两个垂直对齐字段的顶部栏，如下面的截图所示：

图 9.1 – 表单视图的截图

它是如何工作的...

我们首先来看 ir.ui.view 模型的 arch 字段。首先，请注意，视图是在 XML 中定义的，因此你需要为 arch 字段传递 type="xml" 属性；否则，解析器会感到困惑。此外，你的视图定义必须包含格式良好的 XML；否则，当你升级/安装模块时，你会得到一个错误，例如“元素 odoo 有额外内容”。

现在，我们将遍历我们之前使用的标签，并总结其他可用的标签。

form

当你定义一个表单视图时，arch 字段中的第一个元素必须是 form 元素。这在内部用于推导记录的 type 字段。

除了以下元素之外，你还可以在表单标签中使用任意 HTML。算法规定，Odoo 未知的所有元素都被视为纯 HTML，并简单地传递给浏览器。请注意，你填入的 HTML 可以与 Odoo 元素生成的 HTML 代码交互，这可能会扭曲渲染。

此元素是用于在表单的标题中显示的元素的容器，标题以白色栏的形式渲染。通常，如本例所示，你在这里放置操作按钮。或者，如果你的模型有一个 state 字段，你也可以选择一个 状态栏。

button

button 元素用于允许用户触发一个动作。有关详细信息，请参阅 向表单添加按钮 烹饪配方。

<group> 元素是 Odoo 的主要元素，用于组织内容。放置在 <group> 元素内的字段将带有它们的标题，并且同一组内的所有字段都将对齐，以便也有一个视觉指示器表明它们属于一起。你还可以嵌套 <group> 元素；这将导致 Odoo 在相邻的列中渲染包含的字段。

通常情况下，你应该使用 <group> 机制来在表单视图中显示所有字段，只有在必要时才退回到其他元素，例如 <notebook>、<label>、<newline> 以及更多。

如果你将 string 属性分配给一个组，其内容将被渲染为该组的标题。

你还应该养成给每个字段的逻辑组命名的好习惯。这个名称对用户是不可见的，但在我们接下来的配方中覆盖视图时非常有帮助。在表单定义中保持名称唯一，以避免混淆你指的是哪个组。不要使用 string 属性，因为字符串的值最终会因为翻译而改变。

field

为了实际显示和操作数据，你的表单视图应该包含一些 field 元素。以下是一个示例：

<field name="other_info" widget="html"/>

这些有一个必填属性，称为name，它指的是模型中字段的名称。早些时候，我们向用户提供了编辑合作伙伴类别的功能。如果我们只想禁用字段的编辑功能，我们可以将readonly属性设置为1或True。此属性实际上可能包含一小部分 Python 代码，因此readonly="2>1"也会使字段变为只读。这也适用于invisible属性，您曾使用它来获取从数据库读取但不会显示给用户的值。稍后，我们将探讨这种用法可能适用的场景。

您一定注意到了categories字段中的widget属性。这定义了字段中的数据应该如何呈现给用户。每种类型的字段都有一个标准小部件，因此您不必明确选择小部件。然而，几种类型提供了多种表示方式，因此您可能会选择除默认之外的其他方式。由于完整的可用小部件列表超出了本菜谱的范围，请查阅Odoo 的源代码以尝试它们。查看第十四章，CMS 网站开发，以了解如何制作自己的。

`<notebook>`和`<page>`

如果您的模型字段太多，则可以使用<notebook>和<page>标签来创建标签页。<notebook>标签中的每个<page>将创建一个新的标签页，页面内的内容将是标签页的内容。以下示例将创建两个标签页，每个标签页有三个字段：

<notebook>
    <page string="Tab 1">
        <field name="field1"/>
        <field name="field2"/>
        <field name="field3"/>
    </page>
    <page string="Tab 2">
        <field name="field4"/>
        <field name="field5"/>
        <field name="field6"/>
    </page>
</notebook>

<page>标签中的string属性将是标签页的名称。您只能在<notebook>标签中使用<page>标签，但在<page>标签中，您可以使用任何其他元素。

通用属性

在大多数元素上（这包括group、field和button），您可以设置attributes和groups属性。以下是一个小示例：

<field name="other_info"
    readonly="state == 'available'"
    groups="base.group_no_one"/>

虽然attributes在使用属性动态表单元素的菜谱中进行了讨论，但groups属性为您提供了仅向某些组的成员显示某些元素的可能性。简单来说，组的完整 XML ID（多个组之间用逗号分隔）是该属性，并且对于不是至少属于上述提到的组之一的任何成员，该元素都将被隐藏。

其他标签

有时候您可能希望偏离规定的严格布局组。例如，如果您想将记录的name字段渲染为标题，则字段的标签将干扰外观。在这种情况下，不要将字段放入group元素中，而是将其放入普通的 HTMLh1元素中。然后，在h1元素之前，放置一个label元素，并将for属性设置为您的字段名称：

<label for="name" />
<h1><field name="name" /></h1>

这将以字段内容作为大标题进行渲染，但字段名称将写在大标题上方的小字体中。这基本上是标准合作伙伴表单所做的事情。

如果您需要在组内添加换行，请使用 newline 元素。它始终为空：

<newline />

另一个有用的元素是 footer。当您将表单作为弹出窗口打开时，这是一个放置操作按钮的好地方。它也将被渲染为一个单独的栏，类似于 header 元素。

形式视图也包含特殊的部件，例如 web_ribbon。您可以使用 <widget> 标签如下使用它：

<widget name="web_ribbon" title="Archived" bg_color="bg-danger"
invisible="active"/>

您可以使用 attributes 根据条件隐藏和显示功能区。如果您不了解 attributes，请不要担心。它将在本章的 使用属性动态创建表单元素 食谱中介绍。

重要提示

不要指定 string 属性（或任何其他翻译属性），因为您的视图覆盖将因其他语言而中断，因为视图是在应用继承之前进行翻译的。

还有更多…

由于表单视图基本上是带有一些扩展的 HTML，Odoo 也广泛使用了 CSS 类。其中两个非常有用的是 oe_read_only 和 oe_edit_only。具有这些类的元素将仅在 只读模式 或 编辑模式 中可见。例如，要使标签仅在编辑模式下可见，请使用以下代码：

<label f"r="n"me" cla"s="oe_edit_o"ly" />

另一个非常有用的类是 oe_inline，您可以在字段上使用它，使它们渲染为内联元素，以避免造成不想要的换行。当您将字段嵌入文本或其他标记标签时，请使用此类。

此外，form 元素可以有 create、edit 和 delete 属性。如果您将这些属性之一设置为 false，则相应的操作将不会对此表单可用。如果没有明确设置，操作的可用性将根据用户的权限推断。请注意，这纯粹是为了整理用户界面；不要用于安全。

参见

现有的部件和视图已经提供了很多功能，但迟早您会有一些无法用现有部件和视图满足的需求。请参考以下食谱来创建您自己的视图和部件：

请参考本章中关于使用 button 元素触发操作的 添加按钮到表单 食谱以获取更多详细信息。
要定义您自己的部件，请参考 第十五章 的 创建自定义部件 食谱，Web 客户端开发。
请参考 第十五章 的 创建新视图 食谱，Web 客户端开发，以创建您自己的视图。

添加按钮到表单

header 元素。

如何操作...

添加一个指向操作的按钮：

<button type="action" name="%(my_hostel.hostel_room_category_action)d" string="Open Hotel Room Category" />

它是如何工作的...

按钮的 type 属性决定了其他字段的语义，因此我们首先看看可能的值：

action：这将使按钮调用在 ir.actions.* 命名空间中定义的操作。name 属性需要包含操作的数据库 ID，您可以使用包含操作的 XML ID 的 Python 格式字符串方便地让 Odoo 查找。
object：这调用当前模型中的一个方法。name属性包含函数的名称。
string：string属性用于分配用户看到的文本。

还有更多...

使用btn-primary CSS 类来渲染高亮按钮，使用btn-default来渲染普通按钮。这通常用于向导中的取消按钮或以视觉上不引人注目的方式提供次要操作。设置oe_link类会使按钮看起来像链接。您还可以使用其他 Bootstrap 按钮类来获取不同的按钮颜色。

一个带有object类型按钮的调用可以返回一个描述动作的字典，然后将在客户端执行。这样，您可以实现多屏幕向导或只是打开另一个记录。

重要提示

注意，点击按钮总是导致客户端在运行方法之前发出write或create调用。

您还可以通过替换string属性在button标签内添加内容。这通常用于按钮框，如文档风格 表单菜谱中所述。

向表单和动作传递参数 - 上下文

在 Odoo 内部，每个方法都可以访问一个名为context的字典，这个字典从每个动作传播到执行该动作涉及的方法。UI 也可以访问它，并且可以通过在上下文中设置值以各种方式修改它。在这个菜谱中，我们将通过玩弄语言、默认值和隐式过滤器来探索这个机制的一些应用。

准备工作

虽然不是严格必要的，但如果您还没有安装法语，安装法语会使这个菜谱更有趣。请参阅第十一章，国际化，了解如何进行此操作。如果您有法语数据库，将fr_FR更改为其他语言，例如，en_US适用于英语。此外，点击激活按钮（当您悬停时变为存档），以便存档一个宿舍房间并验证此合作伙伴不再出现在列表中。

如何做...

创建一个新的动作，非常类似于添加菜单项和窗口动作菜谱中的动作：

<record id="action_hostel_room" model="ir.actions.act_window">
    <field name="name">All Hostel Room</field>
    <field name="res_model">hostel.room</field>
<field name="view_id" ref="hostel_room_view_tree"/>
    <field name="view_mode">tree,form</field>
    <field name="context">{'lang': 'fr_FR','default_lang': 'fr_FR', 'active_test': False, 'default_room_rating': 1.0}</field>
</record>

添加一个调用此动作的菜单。这留给读者作为练习。

当您打开此菜单时，视图将以法语显示，如果您创建一个新的合作伙伴，它们将法语作为预选语言。一个不那么明显的变化是，您还将看到已停用（存档）的合作伙伴记录。

它是如何工作的...

上下文字典是从几个来源填充的。首先，读取当前用户记录的一些值（用户的语言和用户时区分别为lang和tz）。然后，我们有一些附加组件，它们为了自己的目的添加了键。此外，UI 添加了关于我们目前正在使用的模型和记录的键（active_id、active_ids、active_model）。此外，如通过打开特定视图执行操作配方中所示，我们可以在操作中添加自己的键。这些被合并在一起，并传递给底层服务器函数和客户端 UI。

因此，通过设置lang上下文键，我们强制显示语言为法语。你会注意到这不会改变整个 UI 语言；这是因为只有我们打开的列表视图位于这个上下文范围内。其余的 UI 已经用包含用户原始语言的另一个上下文加载。然而，如果你在这个列表视图中打开一个记录，它也会以法语呈现，如果你在表单上打开一个链接记录或按下执行操作的按钮，语言也会传播。

通过设置default_lang，我们为在这个上下文范围内创建的每个记录设置一个默认值。一般模式是default_$fieldname: my_default_value，这允许你为在这种情况下新创建的合作伙伴设置默认值。鉴于我们的菜单是关于旅舍房间，我们默认为Hostel Average Rating字段添加了default_room_rating: 1作为值。然而，这是一个针对hostel.room的全局默认值，所以这并没有改变任何事情。对于标量字段，语法与你在 Python 代码中写的相同：string字段用引号括起来，number字段保持原样，而Boolean字段是True或False。对于关系字段，语法稍微复杂一些；请参阅第六章，管理模块数据，了解如何编写它们。

重要提示

注意，上下文中设置的默认值会覆盖模型定义中设置的默认值，因此你可以在不同情况下有不同的默认值。

最后一个键是active_test，它具有非常特殊的语义。对于每个具有名为active的字段的模型，Odoo 会自动过滤掉该字段为False的记录。这就是为什么你没有勾选此字段的合作伙伴从列表中消失的原因。通过设置此键，我们可以抑制这种行为。

重要提示

这对于 UI 本身很有用，但在你需要确保操作应用于所有记录，而不仅仅是活动记录时，在你的 Python 代码中更是非常有用。

还有更多...

当定义上下文时，你可以访问一些变量，其中最重要的一个是uid，它评估当前用户的 ID。你需要这个来设置默认过滤器（请参考下一配方，在记录列表上定义过滤器 – 域）。此外，你可以访问context_today函数和current_date变量，前者是一个date对象，代表从用户时区看当前日期，后者是 UTC 时间中的当前日期，格式为YYYY-MM-DD。要将date字段的默认值设置为当前日期，使用current_date，对于默认过滤器，使用context_today()。

此外，你可以使用 Python 的datetime、time和relativedelta类的一个子集进行一些日期计算。

重要提示

大多数域都是在客户端进行评估的。出于安全考虑，服务器端的域评估受到限制。当引入客户端评估时，为了避免整个系统崩溃，最佳选择是将 Python 的一部分实现为 JavaScript。Odoo 内置了一个小的 JavaScript Python 解释器，它对简单的表达式工作得很好，这通常就足够了。

警惕在<record id="action_name" model="ir.actions.act_window.view">快捷方式中使用context变量。这些是在安装时评估的，这几乎从来不是你想要的。如果你需要在你的上下文中使用变量，请使用<record />语法。

我们还可以为按钮添加不同的上下文。这和我们将上下文键添加到我们的操作的方式一样。这会导致按钮调用的函数或操作在给定的上下文中运行。

大多数作为 Python 评估的表单元素属性也都可以访问上下文字典。invisible和readonly属性就是这些属性的例子。因此，在你希望某个元素在某些时候显示在表单中，而在其他时候不显示的情况下，将invisible属性设置为context.get('my_key')。对于导致字段应该不可见的字段的情况，将上下文键设置为my_key: True。这种策略使你能够适应你的表单，而无需为不同场合重写它。

你还可以为关系字段设置上下文，这会影响字段如何加载。通过将form_view_ref或tree_view_ref键设置为视图的完整 XML ID，你可以为这个字段选择一个特定的视图。当你对同一对象有多个相同类型的视图时，这是必要的。如果没有这个键，你会得到序列号最低的视图，这可能并不总是理想的。

参见

上下文还用于设置默认搜索过滤器。你可以通过本章的定义搜索视图配方了解更多关于默认搜索过滤器的内容。
关于设置默认配方的更多细节，请参考下一配方，在记录列表上定义过滤器 – 域。
要了解如何安装法语，请参阅第十一章，国际化。
您可以参考第六章，管理模块数据来学习如何编写关系字段的语法。

在记录列表上定义过滤器 – 域

我们在本章的第一个菜谱中已经看到了一个域的例子，它是[('state', '=', 'draft')]。通常，您需要从操作中显示所有可用记录的子集，或者只允许可能的记录子集成为many2one关系的目标。在 Odoo 中描述这些过滤器的方法是使用域。本菜谱说明了如何使用域来显示合作伙伴的选择。

如何做到这一点...

要显示您操作中的合作伙伴子集，您需要执行以下步骤：

当“状态”设置为“草稿”时创建一个操作：

<record id="action_hostel_room" model="ir.actions.act_window">
    <field name="name">All Hostel Room</field>
    <field name="res_model">hostel.room</field>
<field name="view_id" ref="hostel_room_view_tree"/>
    <field name="view_mode">tree,form</field>
    <field name="context">{'lang': 'fr_FR','default_lang': 'fr_FR', 'active_test': False, 'default_room_rating': 1.0}</field>
    <field name="domain">[('state', '=', 'draft'), ('room_rating', '&gt;', '0.0')]</field>
</record>

添加调用这些操作的菜单。这留给读者作为练习。

它是如何工作的...

域的最简单形式是由三个元组组成的列表，其中包含一个字段名（问题模型中的）作为第一个元素中的string，一个运算符作为第二个元素中的string，以及要检查的字段值作为第三个元素。这是我们之前所做的那样，这被解释为，“所有这些条件都必须适用于我们感兴趣的记录。”这实际上是一个快捷方式，因为域知道两个前缀运算符——&和|——其中&是默认的。因此，在规范形式中，第一个域将如下所示：

['&',('state', '=', 'draft'), ('room_rating', '&gt;', '0.0')]

虽然对于更大的表达式来说这可能有点难以阅读，但前缀运算符的优势在于它们的范围是严格定义的，这可以节省您不必担心运算符优先级和括号。它总是两个表达式：第一个&应用于'&',('state', '=', 'draft')，其中('room_rating', '>', '0.0')作为第一个操作数，('room_rating', '>', '0.0')作为第二个操作数。然后，我们有一个第一个操作数和('room_rating', '>', '0.0')作为第二个操作数。

在第二步，我们必须写出完整形式，因为我们需要|运算符。

例如，假设我们有一个复杂的域，如下所示：['|', ('user_id', '=', uid), '&', ('lang', '!=', 'fr_FR'), '|', ('phone', '=', False), ('email', '=', False)]。参见以下图例了解该域的评估方法：

图 9.2 – 域的评估

此外，还有一个!运算符用于否定，但考虑到逻辑等价和否定比较运算符（如!=和not in），它实际上并不是必需的。

重要提示

注意，这是一个一元前缀运算符，因此它只适用于域中的后续表达式，而不是所有后续的内容。

注意，当你为窗口操作或其他客户端域编写域时，右操作数不需要是固定值。你可以使用与传递参数到表单和操作 – 上下文配方中使用的相同的 Python 最小化版本，因此你可以编写如上周更改或我的合作伙伴之类的过滤器。

参见

对于域的标准应用，请参阅定义搜索视图的食谱。

定义列表视图

在花费了大量时间在表单视图之后，我们现在将快速看一下如何定义列表视图。在内部，这些在某些地方被称为树视图，在其他地方被称为列表视图，但鉴于 Odoo 视图框架中还有一个称为tree的结构，我们将坚持使用列表。

如何做...

定义您的列表视图：

<record id="hostel_room_view_tree" model="ir.ui.view">
    <field name="name">Hostel Room List</field>
    <field name="model">hostel.room</field>
    <field name="arch" type="xml">
        <tree>
            <field name="name"/>
<field name="room_no"/>
            <field name="state"/>
        </tree>
    </field>
</record>

在本章添加菜单项和窗口动作食谱中创建的动作中注册树视图：

<record id="action_hostel_room" model="ir.actions.act_window">
    <field name="name">All Hostel Room</field>
    <field name="res_model">hostel.room</field>
    <field name="view_id" ref="hostel_room_view_tree"/>
    <field name="view_mode">tree,form</field>
<field name="context">{'tree_view_ref': 'my_hostel.hostel_room_view_tree', 'lang': 'fr_FR','default_lang': 'fr_FR', 'active_test': False, 'default_room_rating': 1.0}</field>
    <field name="domain">[('state', '=', 'draft')]</field>
</record>

添加调用这些动作的菜单。这留给读者作为练习。

安装/升级模块。之后，您将看到我们为宿舍房间创建的树视图，如果您检查它，它将根据我们的条件显示不同的行样式。

它是如何工作的...

您已经了解这里发生的大部分内容。我们定义了一个视图，这次使用的是tree类型，并将其与ir.actions.act_window.view元素关联起来。所以，唯一需要讨论的就是tree元素及其语义。在列表中，您没有太多设计选择，因此此元素的唯一有效子元素是field和button元素。您还可以在列表视图中使用一些小部件；在我们的例子中，我们使用了many2one_avatar_user小部件。树视图支持一个特殊的小部件，称为handle。这是针对列表视图的。它用于整数字段，并渲染一个用户可以用来将行拖动到列表中不同位置的拖动把手，从而更新字段的值。这对于序列或优先级字段非常有用。

通过使用optional属性，您可以可选地显示字段。将optional属性添加到字段将允许用户在任何时候从 UI 中隐藏和显示列。在我们的例子中，我们使用了它来为country和state字段。

在tree元素中，这里的新特性是decoration属性。这包含了关于选择哪一种字体和/或颜色的规则，以decoration-$name="Python code"的形式给出。我们将其设置为不可见，因为我们只需要数据，不想让用户被额外的两列所打扰。可能的类包括decoration-bf（粗体）和decoration-it（斜体），以及语义化的 Bootstrap 类decoration-danger、decoration-info、decoration-muted、decoration-primary、decoration-success和decoration-warning。

还有更多...

对于数值字段，你可以添加一个sum属性，使得这一列会与你在属性中设置的文本一起作为工具提示进行求和。较少使用的是avg、min和max属性，它们分别显示平均值、最小值和最大值。请注意，这四个属性只对当前可见的记录有效，因此你可能需要调整动作的limit（在添加菜单项和窗口动作配方中已介绍过），以便用户能够立即看到所有记录。

对于tree元素，有一个非常有趣的属性是editable。如果你将其设置为顶部或底部，列表的行为将完全不同。如果没有设置，点击行会打开行的表单视图。设置了之后，点击行会使其可在线编辑，可见字段被渲染为表单字段。这在嵌入列表视图中尤其有用，这将在本章后面的定义嵌入视图配方中讨论。顶部或底部的选择与是否将在列表的顶部或底部添加新行有关。

默认情况下，记录是按照显示模型的_order属性进行排序的。用户可以通过点击列标题来改变排序，但你也可以通过在tree元素中设置default_order属性来设置不同的初始排序。语法与_order相同。

重要提示

排序常常是新开发者的一个烦恼来源。由于 Odoo 让 PostgreSQL 在这里完成工作，你只能根据 PostgreSQL 所知的字段进行排序，并且只能是对同一数据库表中的字段进行排序。因此，如果你想根据函数或相关字段进行排序，确保你设置了store=True。如果你需要根据从另一个模型继承的字段进行排序，声明一个存储的相关字段。

tree元素的create、edit和delete属性与我们在本章添加内容和小部件到表单视图配方中描述的form元素的工作方式相同。如果设置了editable属性，它们也决定了可用的控件。

定义搜索视图

当你打开列表视图时，你会在右上角注意到搜索字段。如果你在那里输入一些内容，你会收到关于搜索建议，同时还有一个预定义的过滤器组可供选择。本教程将指导你如何定义这些建议和选项。

如何操作...

定义你的搜索视图：

<record id="hostel_room_view_search" model="ir.ui.view">
    <field name="model">hostel.room</field>
    <field name="arch" type="xml">
        <search>
            <field name="name"/>
            <field name="room_no"/>
            <group expand="0" string="Group By">
                <filter string="State" name="state" context="{'group_by':'state'}"/>
           </group>
        </search>
    </field>
</record>

告诉你的动作使用它：

<record id="action_hostel_room" model="ir.actions.act_window">
    <field name="name">All Hostel Room</field>
    <field name="res_model">hostel.room</field>
    <field name="search_view_id" ref="hostel_room_view_search" />
    <field name="view_mode">tree,form</field>
    <field name="context">{'tree_view_ref': 'my_hostel.hostel_room_view_tree', 'lang': 'fr_FR','default_lang': 'fr_FR', 'active_test': False, 'default_room_rating': 1.0}</field>
<field name="domain">[('state', '=', 'draft')]</field>
</record>

现在你可以在搜索栏中输入内容，系统会提供在 name、room no 和 state 字段中搜索此术语的能力。如果你的术语恰好是你系统中银行账户号码的子串，你甚至可以选择精确搜索这个银行账户。

它是如何工作的...

在 name 的情况下，我们只是将字段列为提供给用户搜索的字段。我们保留了默认的语义，即字符字段的子串搜索。

对于类别，我们做了更有趣的事情。默认情况下，你的搜索术语应用于一个名为 name_search 的 many2many 字段触发器，在这种情况下将是对类别名称的子串搜索。然而，根据你的类别结构，搜索具有你感兴趣或其子类别的合作伙伴可能非常方便。想象一下主类别 Newsletter Subscribers，其子类别有 Weekly Newsletter、Monthly Newsletter 和几种其他新闻类型。使用前面的搜索视图定义搜索 Newsletter Subscribers 将一次性给出所有订阅了这些新闻的人，这比逐个搜索每种类型并合并结果要方便得多。

filter_domain 属性可以包含任意域，因此你不仅限于在 name 属性中命名的相同字段进行搜索，也不限于只使用一个术语。self 变量是用户填入的内容，也是你在这里唯一可以使用的变量。

这里有一个来自默认搜索视图的更详细的示例，针对宿舍房间：

<field name="name"
    filter_domain="[
        '|',
        ('display_name', 'ilike', self),
        ('room_no', '=', self)]"/>

这意味着用户不需要考虑要搜索什么。他们只需要输入一些字母，按 Enter 键，如果运气好的话，其中一个字段包含我们正在寻找的字符串。

对于 child_ids 字段，我们使用了另一个技巧。字段的类型不仅决定了搜索用户输入的默认方式，还定义了 Odoo 展示建议的方式。鉴于 many2one 字段是唯一提供自动完成的字段，我们通过设置 widget 属性强制 Odoo 进行自动完成，即使 child_ids 是一个 one2many 字段。如果没有这个设置，我们将不得不在这个字段中进行搜索，而没有完成建议。同样的情况也适用于 many2many 字段。

重要提示

注意，每个设置了 many2one 小部件的字段都会在用户的每个按键时触发其模型上的搜索；不要使用太多。

你还应该将最常用的字段放在顶部，因为如果用户只是键入一些内容并按下 Enter 键，搜索到的将是第一个字段。搜索栏也可以使用键盘操作；通过按下向下箭头选择建议，通过按下右箭头打开 many2one 的完成建议。如果你教育用户了解这一点，并注意搜索视图中字段的合理排序，这将比先键入内容、然后抓取鼠标并选择选项要高效得多。

filter 元素创建了一个按钮，将过滤器的 domain 属性内容添加到搜索域中。你应该添加一个逻辑内部 name 和一个 string 属性来描述过滤器，以便用户了解。

<group> 标签用于在 country_id 字段下提供分组选项。

还有更多...

你可以使用 group 标签来分组过滤器，这使得它们与其他过滤器相比渲染得更靠近一些，但这也有语义上的含义。如果你将多个过滤器放在同一个组中并激活其中多个，它们的域将使用 | 运算符合并，而同一组之外的过滤器和字段将使用 & 运算符合并。有时，你可能希望你的过滤器具有析取性，即它们为互斥集进行过滤，在这种情况下，选择其中两个都会导致一个空的结果集。在同一个组内，你可以通过使用 separator 元素达到相同的效果。

重要提示

注意，如果用户为同一字段填写多个查询，它们也会使用 | 运算符合并，所以你不需要担心这一点。

除了 field 属性外，filter 元素还可以有一个 context 属性，其内容将与当前上下文合并，并最终与其他搜索视图中的上下文属性合并。这对于支持分组的视图至关重要（参考 定义看板视图 和 定义图形视图 菜谱）。因为结果上下文决定了使用 group_by 键进行分组的字段。我们将在适当的菜谱中探讨分组的细节，但上下文还有其他用途。例如，你可以编写一个函数字段，它根据上下文返回不同的值，然后你可以通过激活过滤器来更改这些值。

搜索视图本身也响应上下文键。在创建记录时，与默认值非常类似，你可以通过上下文传递搜索视图的默认值。如果我们之前操作中设置了上下文 {'search_default_room_rating': 1}，那么 room_rating 过滤器就会在搜索视图中预先选中。不过，这仅当过滤器有名称时才有效，这就是为什么你应该始终设置它。要在搜索视图中为字段设置默认值，使用 search_default_$fieldname。

此外，field和filter元素可以有一个与表单视图中相同的语义的groups属性，以便使元素只对某些组可见。

添加搜索过滤器侧面板

Odoo 提供了一种显示搜索过滤器的方法，即搜索过滤器侧面板。此面板在视图的侧边显示过滤器列表。当最终用户频繁使用搜索过滤器时，搜索面板非常有用。

准备工作

搜索面板是搜索视图的一部分。因此，对于这个食谱，我们将继续使用之前食谱中的my_module附加组件。我们将把我们的搜索面板添加到之前设计的搜索视图中。

如何操作...

如下所示，在搜索视图中添加<searchpanel>：

<record id="hostel_room_view_search" model="ir.ui.view">
    <field name="model">hostel.room</field>
    <field name="arch" type="xml">
        <search>
            <field name="name"/>
            <field name="room_no"/>
            <field name="state"/>
            <searchpanel>
                <field name="state" expand="1" select="multi" icon="fa-check-square-o" enable_counters="1"/>
            </searchpanel>
        </search>
    </field>
</record>

更新模块以应用修改。更新后，您将在视图的左侧看到搜索面板。

它是如何工作的...

要添加搜索面板，您需要在搜索视图中使用<searchpanel>标签。要添加您的过滤器，您需要在搜索面板中添加一个字段。

在我们的例子中，首先，我们添加了一个state字段。您还需要将该字段的icon属性添加到其中。这个图标将在过滤器标题之前显示。一旦您将字段添加到搜索面板中，它将显示带有图标的标题，以及下面的所有用户列表。点击用户后，列表视图中的记录将被筛选，您将只能看到所选用户的联系信息。在这个过滤器中，只能有一个活动项，这意味着一旦您点击另一个用户的过滤器，之前的用户过滤器将被移除。如果您想激活多用户过滤器，可以使用select="multi"属性。如果您使用该属性，您将找到每个过滤器选项的复选框，并且您将能够一次激活多个过滤器。我们在state过滤器上使用了select="multi"属性。这将允许我们一次选择和筛选多个类别。

重要提示

当您在many2one或many2many上使用侧面板过滤器时，请小心。如果关系模型有太多记录，为了避免性能问题，只会显示前 200 条记录。

修改现有视图 - 视图继承

到目前为止，我们已忽略现有视图并声明了全新的视图。虽然这在教学上是有意义的，但你很少会处于需要为现有模型定义新视图的情况。相反，你可能会想稍微修改现有视图，无论是为了简单地显示你添加到附加模型中的字段，还是根据你的需求或客户的需求进行定制。

在这个菜谱中，我们将更改默认的合作伙伴表单，通过修改搜索视图来显示记录的最后修改日期，并使mobile字段可搜索。然后，我们将更改合作伙伴列表视图中一列的位置。

如何操作...

将字段注入到默认表单视图：

<record id="hostel_room_view_form_inherit" model="ir.ui.view">
    <field name="name">Hostel Room Form Inherit</field>
    <field name="model">hostel.room</field>
    <field name="inherit_id" ref="my_hostel.hostel_room_view_form" />
    <field name="arch" type="xml">
        <xpath expr="//group[@name='my_content']/group" position="inside">
            <field name="room_no"/>
        </xpath>
        <xpath expr="//group[@name='my_content']/group" position="after">
            <group>
<field name="description"/>
                <field name="room_rating"/>
            </group>
        </xpath>
    </field>
</record>

将字段添加到默认搜索视图：

<record id="hostel_room_view_search_inherit" model="ir.ui.view">
    <field name="name">Hostel Room Search inherit</field>
    <field name="model">hostel.room</field>
    <field name="inherit_id" ref="my_hostel.hostel_room_view_search" />
    <field name="arch" type="xml">
<xpath expr="." position="inside">
            <field name="room_rating"></field>
        </xpath>
    </field>
</record>

将字段添加到默认列表视图：

<record id="hostel_room_view_tree_inherit" model="ir.ui.view">
    <field name="name">Hostel Room List Inherit</field>
    <field name="model">hostel.room</field>
    <field name="inherit_id" ref="my_hostel.hostel_room_view_tree" />
    <field name="arch" type="xml">
        <xpath expr="//field[@name='name']" position="after">
<field name="room_no"/>
        </xpath>
    </field>
</record>

更新你的模块后，你应该在合作伙伴表单的网站字段下方看到最后更新于字段。当你输入某些内容到搜索框时，它应该建议你在移动字段中搜索合作伙伴，在合作伙伴列表视图中，你会看到电话号码和电子邮件的顺序已经改变。

它是如何工作的...

在步骤 1中，我们为表单继承添加了一个基本结构。这里的关键字段，正如你可能猜到的，是inherit_id。你需要将你要修改的视图（继承自）的 XML ID 传递给它。arch字段包含有关如何修改你继承的视图中的现有 XML 节点的说明。实际上，你应该将整个过程视为简单的 XML 处理，因为所有语义部分都将在之后才出现。

在继承视图的arch字段中最经典的指令是field元素，它具有所需的属性：name和position。由于你只能让每个字段在表单中只出现一次，因此名称已经唯一地标识了一个字段。通过position属性，我们可以将我们放在字段元素中的任何内容放置在命名字段之前、内部或之后。默认情况下是inside，但为了可读性，你应该始终命名你需要的位置。记住，我们这里不是在谈论语义；这是关于我们命名的字段在 XML 树中的位置。它之后如何渲染是另一回事。

步骤 2演示了不同的方法。xpath元素选择与expr属性中命名的 XPath 表达式匹配的第一个元素。在这里，position属性告诉处理器将xpath元素的内容放置在哪里。

重要提示

如果你想要基于 CSS 类创建一个 XPath 表达式，Odoo 提供了一个名为hasclass的特殊函数。例如，如果你想选择具有test_class CSS 类的<div>元素，那么表达式将是expr="//div[hasclass('test_class')]"。

步骤 3 展示了如何更改元素的位置。此选项是在phone字段中引入的，以便使用position=move选项在email字段之后出现。

XPath 可能看起来有些吓人，但它是一种非常高效的选择所需操作节点的手段。花点时间查看一些简单的表达式；这是值得的。你可能会遇到术语上下文节点，某些表达式相对于它。在 Odoo 的视图继承系统中，这始终是你正在继承的视图的根元素。

对于在继承视图的arch字段中找到的所有其他元素，处理器会寻找具有相同节点名称和匹配属性（排除属性位置，因为这属于指令的一部分）的第一个元素。仅在非常不可能出现这种组合不唯一的情况下使用此功能，例如将组元素与name属性组合。

重要提示

注意，你可以在arch字段中包含尽可能多的指令元素。我们只为每个继承视图使用了一个，因为我们目前没有其他想要更改的内容。

还有更多...

position属性有两个其他可能的值：replace和attributes。使用replace会导致选定的元素被指令元素的内容替换。因此，如果你没有任何内容，选定的元素可以简单地被移除。前面的列表或表单视图会导致state字段被移除：

<field name="state" position="replace" />

重要提示

移除字段可能会导致其他继承视图损坏，并产生几个其他不希望出现的副作用，因此如果可能的话，请避免这样做。如果你确实需要移除字段，请在评估顺序较晚的视图中进行（有关更多信息，请参阅下一节，视图继承中的评估顺序）。

attributes与前面的示例具有非常不同的语义。处理器期望元素包含具有name属性的attribute元素。然后，这些元素将被用于设置选定元素的属性。如果你想注意之前的警告，你应该将state字段的invisible属性设置为1：

<field name="state" position="attributes">
    <attribute name="invisible">1</attribute>
</field>

一个attribute节点可以有add和remove属性，这些属性反过来应该包含要从或添加到空格分隔列表中的值。这对于class属性非常有用，你可以通过以下方式添加一个类（而不是覆盖整个属性）：

<field name="description" position="attributes">
    <attribute name="class" add="oe_inline" separator=" "/>
</field>

此代码将oe_inline类添加到description字段。如果该字段已经存在类属性，Odoo 会将该值与separator属性的值合并。

视图继承中的评估顺序

由于我们目前只有一个父视图和一个继承视图，因此不会遇到任何视图覆盖冲突的问题。当你安装了几个模块后，你会发现有很多针对合作伙伴表单的覆盖。只要它们在视图中更改不同的内容，这就可以了，但在某些情况下，了解覆盖的工作原理以避免冲突是很重要的。

视图的直接后代按其 priority 字段的升序评估，因此优先级较低的视图首先应用。继承的每一步都应用于第一步的结果，所以如果一个优先级为 3 的视图更改了一个字段，而另一个优先级为 5 的视图删除了它，这是可以的。然而，如果优先级相反，则不起作用。

你还可以从视图继承一个继承视图本身。在这种情况下，第二级继承视图应用于它继承的视图的结果。所以，如果你有四个视图，A、B、C 和 D，其中 A 是一个独立的表单，B 和 C 从 A 继承，而 D 从 B 继承，评估的顺序是 A、B、D 和 C。使用这一点来强制执行顺序，而无需依赖于优先级；这在一般情况下更安全。如果一个继承视图添加了一个字段，你需要对此字段应用更改，那么应该从继承视图继承，而不是从独立视图继承。

重要提示

这种继承始终在原始视图的完整 XML 树上工作，并应用了之前继承视图的修改。

以下要点提供了关于一些用于调整视图继承行为的先进技巧的信息：

对于继承视图，有一个非常有用但不太为人所知的字段是 groups_id。该字段仅在请求父视图的用户是那里提到的某个组的成员时才会发生继承。这可以在为不同级别的访问调整用户界面时节省你大量的工作，因为，通过继承，你可以执行比仅基于组成员显示或隐藏元素更复杂的操作，就像表单元素的 groups 属性所做的那样。
例如，如果用户是某个组的成员，你可以删除元素（这是 groups 属性的相反操作）。你还可以执行一些复杂的技巧，例如根据组成员添加属性。考虑一些简单的事情，比如使某些组的字段只读，或者更有趣的概念，比如为不同的组使用不同的小部件。
本菜谱中描述的内容与原始视图的 mode 字段设置为 primary 有关，而继承视图有模式扩展，这是默认设置。我们将在稍后研究继承视图的 mode 设置为 primary 的情况，那里的规则略有不同。

定义文档样式表单

在这个菜谱中，我们将回顾一些设计指南，以便提供一致的用户体验。

如何做到这一点...

使用header元素开始你的表单：

<header>
    <button name="make_available" string="Make Available" type="object"/>
    <button name="make_closed"  string="Make Closed" type="object"/>
    <button type="action" name="%(my_hostel.hostel_room_category_action)d"        string="Open Hotel Room Category" />
    <field name="state" widget="statusbar"/>
sheet element for content:

状态按钮，将用于显示宿舍房间总数，并将重定向到宿舍房间：

<div class="oe_button_box" name="button_box">
    <button type="object" class="oe_stat_button" icon="fa-pencil-square-o" name="action_open_related_hostel_room">
        <div class="o_form_field o_stat_info">
            <span class="o_stat_value">
                 <field name="related_hostel_room"/>
            </span>
            <span class="o_stat_text">Hostel Room</span>
        </div>
    </button>
</div>

添加一些突出的字段：

<div class="oe_title">
    <h1>
        <field name="name"/>
    </h1>
</div>

添加你的内容；如果有许多字段，可以使用笔记本：

<group>
    <field name="child_ids"/>
    <field name="hoste_room_ids" widget="many2many_tags"/>
chatter widget (if applicable):

让我们看看这个菜谱是如何工作的。

它是如何工作的...

标题应包含执行用户当前看到对象操作的按钮。使用btn-primary类使按钮在视觉上突出（在撰写时为紫色），这是一种指导用户关于此刻最合理的操作的好方法。尽量将所有突出显示的按钮放在非突出显示按钮的左侧，并隐藏当前状态下不相关的按钮（如果适用）。如果模型有状态，请使用statusbar小部件在标题中显示它。这将在标题中右对齐渲染。

sheet元素被渲染为风格化的表格，最重要的字段应该是用户查看时的第一件事。使用oe_title类使它们在显眼的位置渲染（在撰写时浮动在左侧，字体大小略有调整）。

如果有其他与用户当前查看的记录相关的记录（例如合作伙伴表单上的合作伙伴发票），请将它们放在具有oe_right和oe_button_box类的元素中；这将使其中的按钮右对齐。在按钮本身上，使用oe_stat_button类强制执行按钮的统一渲染。根据惯例，还从icon属性分配一个图标类。你可以在fontawesome.com/v4.7.0/icons/上了解更多关于 Font Awesome 的信息。

你可以使用oe_chatter类和mail.thread混入。我们将在第二十三章，Odoo 中的电子邮件管理中详细说明。

重要提示

即使你不喜欢这个布局，也要坚持使用这里描述的元素和类名，并使用 CSS 和可能的 JavaScript 调整你需要的内容。这将使用户界面与现有插件更加兼容，并允许你更好地与核心插件集成。

参见

要了解更多关于 Font Awesome 的信息，请访问fontawesome.com/v4.7.0/icons/。
要了解更多关于mail.thread混入的详细信息，请参阅第二十三章，Odoo 中的电子邮件管理。

使用属性动态表单元素

到目前为止，我们只研究了根据用户的组（元素的groups属性和继承视图的groups_id字段）更改表单，没有更多。这个配方将向你展示如何根据表单中字段的值修改表单视图。

如何操作...

在表单元素上定义一个名为attributes的属性：

<field name="child_ids"
    invisible="not parent_id"
    required="parent_id"/>

确保你引用的所有字段都在你的表单中可用：
```
<field name="parent_id"/>
```

如果parent_id不是“宿舍房间类别”，这将使child_ids字段不可见，如果是宿舍房间类别，则将是必填项。

它是如何工作的...

invisible、required和readonly键（所有这些都是可选的）。值是可能引用表单上存在的字段（实际上只有那些，所以没有点路径），整个字典根据客户端 Python 的规则进行评估，如本章中将参数传递给表单和操作 - 上下文配方中所述。因此，例如，你可以在右手操作数中访问上下文。

还有更多...

虽然对于标量字段，这个机制相当直接，但对于one2many和many2many字段，处理起来就不那么明显了。实际上，在标准的 Odoo 中，你无法在[[6, False, []]]（你的右手操作数）中做太多关于那些字段的事情。

定义嵌入视图

当你在表单上显示one2many或many2many字段时，如果你没有使用专门的控件，你将无法控制其渲染方式。此外，在many2one字段的情况下，有时可能希望能够影响打开链接记录的方式。在这个配方中，我们将探讨如何为这些字段定义私有视图。

如何操作...

按照惯例定义你的领域，但不要关闭标签：
```
<field name="hostel_room_ids">
```

将视图定义写入标签：

<tree>
    <field name="name"/>
    <field name="room_no"/>
</tree>
<form>
    <sheet>
        <group>
            <field name="name"/>
            <field name="room_no"/>
</group>
    </sheet>
</form>

关闭标签：
```
</field>
```

它是如何工作的...

当 Odoo 加载表单视图时，它首先检查字段中是否有嵌入视图的relational类型字段，如前所述。这些嵌入视图可以具有与我们之前定义的视图完全相同的元素。只有当 Odoo 找不到某种类型的嵌入视图时，它才会使用该类型的模型默认视图。

还有更多...

虽然嵌入视图可能看起来是一个很好的功能，但它们极大地复杂化了视图继承。例如，一旦涉及到嵌入视图，字段名称就不保证是唯一的，你通常必须使用一些复杂的 XPath 来选择嵌入视图内的元素。

因此，总的来说，你最好定义独立的视图，并使用前面在本章中让操作打开特定视图配方中描述的form_view_ref和tree_view_ref键。

在表单视图的侧边显示附件

在某些应用程序中，例如开票，你需要根据文档填写数据。为了简化数据填写过程，Odoo 12 版本中添加了一个新功能，在表单视图的侧边显示文档。

在本教程中，我们将学习如何并排显示表单视图和文档视图：

图 9.3 – 级联附件和表单视图

重要提示

此功能仅适用于大屏幕（>1534px），因此如果您有较小的视口，此功能将被隐藏。内部，此功能使用一些响应式工具，因此此功能仅在企业版中工作。然而，您仍然可以在您的模块中使用此代码。Odoo 将自动处理此操作，因此如果模块安装在企业版中，它将显示文档，而在社区版中，它将隐藏所有内容而不会产生任何副作用。

如何操作...

我们将启用此功能以修改hostel.room.category模型的表单视图，如下所示：

<record id="hostel_room_category_view_form" model="ir.ui.view">
    <field name="name">Hostel Room Categories Form</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <form>
            <sheet>
                <div class="oe_button_box" name="button_box">
                    <button type="object" class="oe_stat_button" icon="fa-pencil-square-o" name="action_open_related_hostel_room">
                        <div class="o_form_field o_stat_info">
                            <span class="o_stat_value">
                                <field name="related_hostel_room"/>
                            </span>
                            <span class="o_stat_text">Hostel Room</span>
                        </div>
                    </button>
                </div>
                <div class="oe_title">
                   <h1>
                        <field name="name"/>
                    </h1>
                </div>
                <group>
                    <group>
                        <field name="description"/>
                    </group>
                    <group>
                        <field name="parent_id"/>
                    </group>
                </group>
                <group>
                    <field name="child_ids"
                           invisible="not parent_id"
                           required="parent_id"/>
                    <field name="hoste_room_ids">
                        <tree>
                            <field name="name"/>
                            <field name="room_no"/>
                        </tree>
                        <form>
                            <sheet>
                                <group>
                                    <field name="name" />
                                    <field name="room_no"/>
                                </group>
                            </sheet>
                        </form>
                    </field>
                </group>
            </sheet>
            <div class="o_attachment_preview" options="{'types': ['image', 'pdf'], 'order': 'desc'}"/>
            <div class="oe_chatter">
                <field name="message_follower_ids" widget="mail_followers"/>
                <field name="message_ids" widget="mail_thread"/>
                <field name="activity_ids" widget="mail_activity"/>
            </div>
        </form>
    </field>
</record>

更新模块以应用更改。您需要通过记录聊天上传 PDF 或图像。当您上传时，Odoo 将在侧边显示附件。

工作原理...

此功能仅在您的模型继承了mail.thread模型时才有效。要显示任何表单视图侧边的文档，您需要在聊天元素之前添加一个带有o_attachment_preview类的空<div>。就是这样；聊天中附加的文档将在表单视图的侧边显示。

默认情况下，pdf和image文档将按日期升序显示。您可以通过提供额外的选项来更改此行为，以下是一些选项：

type：您需要传递您想要允许的文档类型列表。只有两个可能的值：pdf和image。例如，如果您只想显示pdf类型的图像，您可以传递{'type': ['pdf']}。
order：可能的值是asc和desc。这些选项允许您按文档创建日期的升序或降序显示文档。

还有更多...

在大多数情况下，您希望在记录的初始状态下显示文档。如果您想根据领域隐藏附件预览，您可以使用<div>标签上的attributes来隐藏预览。

看以下示例：如果state字段的值不是draft，它将隐藏 PDF 预览：

<div class="o_attachment_preview"
    invisible="state != 'draft'"/>

这就是您可以在不需要时隐藏附件的方法。通常，此功能用于从 PDF 中填充数据，并且仅在草稿模式下激活。

定义看板视图

到目前为止，我们已经向您展示了一系列可以打开以显示表单的记录。虽然这些列表在展示大量信息时效率很高，但由于缺乏设计可能性，它们往往显得有些单调。在本教程中，我们将探讨看板视图，它允许我们以更具吸引力的方式展示记录列表。

如何操作...

定义一个kanban类型的视图：

<record id="hostel_room_category_view_kanban" model="ir.ui.view">
    <field name="name">Hostel Room Categories kanban</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <kanban class="o_kanban_mobile" sample="1">

列出您在视图中将使用的字段：

    <field name="name"/>
    <field name="description"/>
    <field name="parent_id"/>

实施设计：

<templates>
    <t t-name="kanban-box">
        <div t-attf-class="oe_kanban_global_click">
             <div class="row mb4">
                 <div class="col-6 o_kanban_record_headings">
                     <strong>
                         <span>
                             <field name="name"/>
                         </span>
                     </strong>
                  </div>
                  <div class="col-6 text-end">
                      <strong><i role="img" title="description"/>
                          <t t-esc="record.description.value"/></strong>
                     </div>
                </div>
                <div class="row">
                     <div class="col-12">
                          <span><field name="parent_id"/></span>
                     </div>
                </div>
           </div>
     </t>
</templates>

关闭所有标签：

        </kanban>
    </field>
</record>

将此视图添加到您的某个操作中。这留作读者的练习。您可以在 GitHub 示例文件中找到一个完整的示例：github.com/PacktPublishing/Odoo-13-Development-Cookbook-Fourth-Edition/tree/master/Chapter09/15_kanban_view/my_module。

它是如何工作的...

为了以后能够访问它们，我们需要在步骤 2中提供一个要加载的字段列表。templates元素的内容必须是一个具有t-name属性设置为kanban-box的单个t元素。

您在这个元素内部写入的内容将为每个记录重复，对于t元素和t-*属性有特殊的语义。有关详细信息，请参阅第十五章的使用客户端 QWeb 模板配方，Web 客户端开发，因为从技术上讲，看板视图只是 QWeb 模板的应用。

对于看板视图，有一些特定的修改。在评估期间，您可以访问read_only_mode、record和widget变量。字段可以通过record.fieldname访问，这是一个具有value和raw_value属性的对象，其中value是已格式化以供用户展示的字段值，而raw_value是来自数据库的字段值。

重要提示

many2many字段在这里是个例外。您只能通过record变量获取一个 ID 列表。对于用户可读的表示，您必须使用field元素。

注意模板顶部的type属性。此属性使 Odoo 生成一个以查看模式打开记录的链接（type属性也可以是object或action，这将渲染从模型或操作调用的函数的链接。在两种情况下，您都需要补充表单视图中按钮的属性，如本章中向表单添加按钮配方中概述的那样。您也可以使用button元素；这里的type属性具有相同的语义。

还有更多...

还有几个值得注意的辅助函数。如果您需要为元素生成伪随机颜色，请使用kanban_color(some_variable)函数，它将返回一个设置background和color属性的 CSS 类。这通常用于t-att-class元素。

如果您想显示存储在二进制字段中的图像，请使用kanban_image(modelname, fieldname, record.id.raw_value)，如果您在字段列表中包含了该字段，则它返回一个数据 URI；如果字段已设置，则为占位符；如果没有设置，则为 URL，如果未在字段列表中包含该字段，则 Odoo 会流式传输字段的内容。如果您需要同时显示大量记录或预期非常大的图像，请不要在字段列表中包含该字段。通常，您会在img元素的t-att-src属性中使用此功能。

重要提示

在看板视图中进行设计可能会有些棘手。通常更好的方法是使用 HTML 类型的函数字段生成 HTML，并从 Qweb 视图中生成这个 HTML。这样，你仍然在使用 QWeb，但是在服务器端进行，当你需要处理大量数据时，这会变得更加方便。

根据状态在列中显示看板卡片

此配方向您展示了如何设置一个看板视图，用户可以从一列拖放记录到另一列，从而将相关记录推入另一个状态。

准备工作

从现在起，我们将在这里使用宿舍模块，因为它定义了比基础模块中定义的更适合基于日期和状态的视图的模型。因此，在继续之前，将base添加到您的附加组件的依赖项列表中。

如何操作...

定义宿舍房间类别的看板视图：

<record id="hostel_room_category_view_kanban" model="ir.ui.view">
    <field name="name">Hostel Room Categories kanban</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <kanban class="o_kanban_mobile" sample="1" default_group_by="parent_id">
            <field name="name"/>
            <field name="description"/>
            <templates>
                <t t-name="kanban-box">
                    <div t-attf-class="oe_kanban_global_click">
                        <div class="row mb4">
                            <div class="col-6 o_kanban_record_headings">
                                <strong>
                                    <span>
                                        <field name="name"/>
                                    </span>
                               </strong>
                           </div>
                           <div class="col-6 text-end">
                               <strong><i role="img" title="description"/> <t t-esc="record.description.value"/></strong>
                           </div>
                       </div>
                       <div class="row">
                           <div class="col-12">
                               <span><field name="parent_id"/></span>
                           </div>
                       </div>
                   </div>
               </t>
           </templates>
       </kanban>
    </field>
</record>

使用此视图添加一个菜单和一个动作。这留给读者作为练习。

它是如何工作的...

看板视图支持分组，这允许你在同一列中显示具有共同分组字段的记录。这通常用于父酒店房间类别或parent_id字段，因为它允许用户通过简单地将其拖入另一列来更改记录的此字段值。将default_group_by属性设置在kanban元素上，以使用你想要分组的字段名称来利用此功能。

要控制看板分组的操作，Odoo 中提供了一些选项：

group_create：此选项用于隐藏或显示true。
group_delete：此选项启用或禁用true。
group_edit：此选项启用或禁用true。
archivable：此选项启用或禁用从看板分组上下文菜单中存档和恢复记录的选项。这仅在您的模型中存在active布尔字段时才有效。
quick_create：使用此选项，您可以直接从看板视图中创建记录。
quick_create_view：默认情况下，quick_create选项仅在看板中显示名称字段。然而，使用quick_create_view选项，你可以提供最小表单视图的引用，以便在看板中显示它。
on_create：如果你在创建新记录时不希望使用quick_create，也不希望将用户重定向到表单视图，你可以提供向导的引用，以便在点击创建按钮时打开向导。

还有更多...

如果未在专用属性中定义，任何搜索过滤器都可以通过将名为group_by的上下文字符串设置为要按其分组的字段名称（名称）来添加分组。

定义日历视图

这个菜谱将指导你如何以可视化的方式显示和编辑记录中关于日期和持续时间的详细信息。

如何操作...

按以下步骤为hostel.room.category模型添加calendar视图：

定义calendar视图：

<record id="hostel_room_category_view_calendar" model="ir.ui.view">
    <field name="name">Hostel Room Categories Calendar</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <calendar date_start="date_assign" date_stop="date_end" color="parent_id">
            <field name="name" />
            <field name="parent_id" />
        </calendar>
    </field>
</record>

使用此视图添加菜单和操作。这留给读者作为练习。

它是如何工作的...

calendar视图需要通过date_start和date_stop属性传递字段名称，以指示在构建视觉表示时查看哪些字段。仅使用具有Datetime或Date类型的字段；其他类型的字段将不起作用，并会生成错误。虽然date_start是必需的，但你可以选择省略date_stop，并设置date_delay属性，它预期是一个表示持续时间的Float字段。

calendar视图允许你为具有相同字段值的记录分配相同的（任意指定的）颜色。要使用此功能，将color属性设置为所需的字段名称。在我们的例子中，我们可以一眼看出哪些宿舍房间类别属于同一宿舍房间类别，因为我们把parent_id作为字段来决定颜色组。

在calendar元素的主体中命名的字段将在表示覆盖时间间隔的块中显示，字段之间用逗号分隔。

还有更多...

calendar视图还有一些其他有用的属性。如果你想通过弹出窗口而不是标准表单视图打开日历条目，将event_open_popup设置为1。默认情况下，你只需填写一些文本即可创建新条目，这实际上会调用模型的name_create函数来创建记录。如果你想禁用此行为，将quick_add设置为0。

如果你的模型覆盖了整整一天，将all_day设置为字段名称，如果记录覆盖了整整一天则为true，否则为false。

定义图形视图和交叉视图

在这个菜谱中，我们将查看 Odoo 的商业智能视图。这些是只读视图，旨在展示数据。

准备工作

我们在这里仍然使用 hostel 模块。你可以配置图表和交叉视图以获取不同的统计数据。在我们的例子中，我们将专注于分配的用户。我们将生成一个图表和交叉视图来查看宿舍房间类别的用户。顺便说一句，最终用户可以通过修改视图选项来生成他们选择的统计数据。

如何操作...

使用条形图定义一个图表视图：

<record id="hostel_room_category_view_graph" model="ir.ui.view">
    <field name="name">Hostel Room Categories Graph</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <graph type="bar">
            <field name="parent_id"/>
            <field name="child_ids"/>
        </graph>
    </field>
</record>

定义一个交叉视图：

<record id="hostel_room_category_view_pivot" model="ir.ui.view">
    <field name="name">Hostel Room Categories Pivot</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <pivot>
            <field name="parent_id" type="row"/>
            <field name="name" type="col"/>
        </pivot>
    </field>
</record>

使用此视图添加菜单和操作。这留给读者作为练习。

如果一切顺利，你应该会看到图表显示分配给哪些宿舍房间类别的父宿舍房间类别以及这些宿舍房间类别的状态。

它是如何工作的...

图表视图通过根元素 graph 声明。graph 元素上的 type 属性决定了图表视图的初始模式。可能的值是 bar、line 和 chart，但默认是 bar。图表视图高度交互式，因此用户可以在不同的模式之间切换，也可以添加和删除字段。如果你使用 type="bar"，你还可以使用 stacked="1" 在分组时显示堆叠条形图。

field 元素告诉 Odoo 在哪个轴上显示什么。对于所有图表模式，你需要至少一个 row 类型的字段和一个 measure 类型的字段才能看到有用的内容。row 类型的字段确定分组，而 measure 类型的字段代表要显示的值。折线图只支持每种类型的一个字段，而图表和条形图可以很好地处理一个度量值和两个分组字段。

交叉视图有其自己的根元素，pivot。交叉视图支持任意数量的分组和度量字段。如果你切换到一个不支持你定义的分组和度量数量的模式，不会发生任何问题；一些字段将被忽略，结果可能不如预期那么有趣。

还有更多...

对于所有图表类型，Datetime 字段在分组时很棘手，因为你很少会遇到相同的字段值。所以，如果你有一个 row 类型的 Datetime 字段，也请指定以下值之一的 interval 属性：day、week、month、quarter 或 year。这将导致分组在给定的间隔内进行。

重要提示

分组，就像排序一样，高度依赖于 PostgreSQL。因此，这里的规则也适用，即一个字段必须存在于数据库和当前表中才能被使用。

定义数据库视图以收集所需的所有数据，并在该视图之上定义一个模型，以便所有必要的字段都可用，这是一种常见的做法。

根据视图的复杂性和分组，构建图表可能是一项相当昂贵的操作。在这种情况下，考虑将 auto_search 属性设置为 False，以便用户可以先调整所有参数，然后再触发搜索。

交叉表也支持按列分组。使用col类型为要添加的字段。

定义队列视图

对于记录的队列分析，新的队列视图是在 Odoo 版本 12 中添加的。队列视图用于找出记录在特定时间跨度内的生命周期。使用队列视图，您可以查看任何对象在特定时间内的流失和留存率。

准备工作

cohort视图是模块清单文件中的web_cohort的一部分。在我们的示例中，我们将创建一个视图来查看宿舍房间类别的队列分析。

如何操作...

按照以下步骤为hostel.room.category模型添加cohort视图：

定义一个cohort视图：

<record id="hostel_room_category_view_cohort" model="ir.ui.view">
    <field name="name">Hostel Room Categories Cohort</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <cohort date_start="date_assign" date_stop="date_end" interval="month" string="Categories Cohort" />
    </field>
</record>

使用此视图添加菜单和操作。这留给读者作为练习。

它是如何工作的...

要创建队列视图，您需要提供date_start和date_stop。这些将在视图中用于确定任何记录的时间跨度。例如，如果您正在管理一项服务的订阅，则订阅的开始日期将是date_start，而订阅即将到期的日期将是date_stop。

默认情况下，cohort视图将以每月的间隔在retention模式下显示。您可以使用提供的选项在cohort视图中获得不同的行为：

mode: 您可以使用两种模式使用队列：retention (默认)或churn。retention模式从 100%开始并随时间递减，而churn模式从 0%开始并随时间递增。
timeline: 此选项接受两个值：forward (默认)或backward。在大多数情况下，您需要使用前向时间线。然而，如果date_start在将来，您将需要使用后向时间线。我们使用后向时间线的例子可能是为未来日期的事件注册参会者，而注册日期在过去的场景。
interval: 默认情况下，队列按月分组，但您可以在间隔选项中更改此设置。除了月份外，队列还支持按日、周和年间隔分组。
measure: 就像图形和交叉表一样，度量用于显示给定字段的聚合值。如果没有提供选项，队列将显示记录数。

定义甘特图视图

Odoo 版本 13 添加了一个新的带有新选项的gantt视图。gantt视图对于查看整体进度和调度业务流程非常有用。在本菜谱中，我们将创建一个新的gantt视图并查看其选项。

准备工作

gantt视图是 Odoo 企业版的组成部分，因此您不能在社区版中使用它。如果您使用的是企业版，您需要在模块的清单文件中添加web_gantt依赖项。

在我们的示例中，我们将继续使用之前菜谱中的my_hostel模块。我们将为宿舍房间类别创建一个新的gantt视图。

如何操作...

按如下方式为宿舍房间类别模型定义一个 gantt 视图：

<record id="hostel_room_category_view_gantt" model="ir.ui.view">
    <field name="name">Hostel Room Categories Gantt</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <gantt date_start="date_assign" date_stop="date_end" string="Hostel Room Category" default_group_by="parent_id" color="parent_id">
            <field name="name"/>
            <field name="parent_id"/>
            <templates>
                <div t-name="gantt-popover" >
                    <ul class="pl-1 mb-0 list-unstyled">
                        <li>
                            <strong>Name: </strong>
                            <t t-esc="name"/>
                       </li>
                       <li>
                            <strong>Parent Category: </strong>
                            <t t-esc="parent_id[1]"/>
                       </li>
                   </ul>
               </div>
           </templates>
       </gantt>
    </field>
</record>

使用此视图添加菜单和操作。这留作读者的练习。

安装并更新模块以应用更改；更新后，您将在宿舍房间类别中看到 gantt 视图。

它是如何工作的...

使用 gantt 视图，您可以在一个屏幕上显示整体进度表。在我们的示例中，我们为按父类别分组的宿舍房间类别创建了一个 gantt 视图。通常，您需要两个属性来创建 gantt 视图，即 start_date 和 stop_date，但还有一些其他属性可以扩展 gantt 视图的功能。让我们看看所有选项：

start_date: 定义 gantt 项的起始时间。它必须是日期或日期时间字段。
default_group_by: 如果您想根据字段对 gantt 项进行分组，请使用此属性。
color: 此属性用于决定 gantt 项的颜色。
progress: 此属性用于指示 gantt 项目的进度。
decoration-*: 装饰属性用于根据条件决定 gantt 项的颜色。它可以这样使用：decoration-danger="state == 'lost'"。它的其他值是 decoration-success、decoration-info、decoration-warning 和 decoration-secondary。
scales: 如果您只想为少数几个刻度启用 gantt 视图，请使用 scales 属性。例如，如果您只想使用日和周刻度，则可以使用 scales="day,week"。
默认情况下，gantt 视图项可调整大小和可拖动，但如果您想禁用此功能，则可以使用 edit="0" 属性。

定义活动视图

活动是 Odoo 应用程序的重要组成部分。它们用于为不同的业务对象安排待办事项。activity 视图帮助您查看模型上所有活动的状态和进度。

准备工作

在我们的示例中，我们将继续使用前一个菜谱中的 my_hostel 模块。我们将为宿舍房间类别创建一个新的 activity 视图。

如何做...

按如下方式为 hostel room category 模型定义一个 activity 视图：

<record id="hostel_room_category_view_activity" model="ir.ui.view">
    <field name="name">Hostel Room Categories Activity</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <activity string="Hostel Room Category">
            <templates>
                <div t-name="activity-box">
                    <div>
                        <field name="name" display="full"/>
                        <field name="parent_id" muted="1" display="full"/>
                   </div>
               </div>
           </templates>
       </activity>
    </field>
</record>

使用此视图添加菜单和操作。这留作读者的练习。

它是如何工作的...

activity 视图很简单；大多数事情都是自动管理的。您只有自定义第一列的选项。要显示第一列中的数据，您需要创建一个名为 activity-box 的 QWeb 模板，然后就可以了；Odoo 将管理其余部分。

activity 视图将在第一列显示您的模板，其他列将显示按活动类型分组的预定活动。

定义地图视图

Odoo 版本 13 增加了一个名为“地图”的新视图。正如其名所示，它用于显示带有标记的地图。它们对于现场服务非常有用。

准备工作

在我们的例子中，我们将继续使用之前菜谱中的my_hostel模块。我们将为宿舍房间类别创建新的map视图。map视图是模块清单文件中web_map依赖的一部分。

Odoo 使用来自www.mapbox.com/的 API 在视图中显示地图。为了在 Odoo 中查看地图，您需要从mapbox生成访问令牌。请确保您已生成访问令牌并将其设置在 Odoo 配置中。

如何操作…

按照以下方式为宿舍房间类别模型定义一个map视图：

<record id="hostel_room_category_view_map" model="ir.ui.view">
    <field name="name">Hostel Room Categories Map</field>
    <field name="model">hostel.room.category</field>
    <field name="arch" type="xml">
        <map>
            <field name="name" string="Title "/>
            <field name="parent_id" string="Hostel Room Category "/>
        </map>
    </field>
ss</record>

使用此视图添加菜单和操作。这留作读者的练习。

它是如何工作的...

创建地图视图相当简单；您只需要一个many2one字段，该字段引用hostel.room.category模型。hostel.room.category模型有address字段，这些字段被地图视图用于显示地址的标记。您需要使用res_partner属性将地址映射到map视图。在我们的例子中，我们使用了parent_id字段作为在parent_id字段中设置的宿舍房间类别父记录集。

第十章：安全访问

Odoo 通常被多用户组织使用。每个用户在每一个组织中都有一个独特的职位，并且根据他们的职能有不同的访问权限。例如，人力资源经理没有访问公司会计信息的权限。您可以使用访问权限和记录规则来确定用户在 Odoo 中可以访问哪些信息。在本章中，我们将学习如何设置访问权限规则和记录规则。

这种访问和安全的细分要求我们根据其权限级别提供对角色的访问。我们将在本章中了解这一点。

在本章中，我们将涵盖以下食谱：

创建安全组并将它们分配给用户
向模型添加安全访问
限制模型中字段的访问
使用记录规则来限制记录访问
使用安全组激活功能
以超级用户身份访问记录集
根据组隐藏视图元素和菜单

为了简洁地传达要点，本章中的食谱对现有示例模块进行了小的补充。

技术要求

本章的技术要求包括使用我们根据第三章，创建 Odoo 附加模块中的教程创建的模块。为了遵循这里的示例，您应该已经创建了该模块并准备好使用。

本章中将要使用的所有代码都可以从本书的 GitHub 仓库中下载，网址为github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter10。

创建安全组并将它们分配给用户

Odoo 中的安全访问通过安全组进行配置：权限被授予组，然后组被分配给用户。每个功能区域都有一个由中央应用程序提供的基本安全组。

当附加模块增强现有应用程序时，它们应该向相应的组添加权限，如向模型添加安全访问食谱中所述。

当附加模块引入一个尚未被现有核心应用程序覆盖的新功能区域时，应添加相关的安全组。我们通常至少应该有用户和管理角色。

以我们介绍的宿舍示例第三章，创建 Odoo 附加模块为例——它并不适合任何 Odoo 核心应用程序，因此我们将为它添加安全组。

准备工作

本教程假设您已经准备好一个 Odoo 实例，其中包含my_hostel，如第三章中所述，创建 Odoo 附加模块。

如何做...

要向模块添加新的访问安全组，请执行以下步骤：

确保附加模块的__manifest__.py声明文件中定义了category键：
```
    'category': Hostel,
```

将新的security/groups.xml文件添加到清单的data键：

    'data': [
        'security/groups.xml',
    ],

将数据记录的新 XML 文件添加到security/groups.xml文件中，从空结构开始：

<?xml version="1.0" encoding="utf-8"?>
<odoo>
    <!--  Add step 4 goes here -->
</odoo>

在数据 XML 元素内部添加两个新组的<record>标签：

<record id="group_hostel_user" model="res.groups">
     <field name="name">User</field>
     <field name="category_id"
            ref="base.module_category_hostel"/>
     <field name="implied_ids"
            eval="[(4, ref('base.group_user'))]"/>
</record>
<record id="group_hostel_manager" model="res.groups">
    <field name="name">Manager</field>
    <field name="category_id"
           ref="base.module_category_hostel"/>
    <field name="implied_ids"
           eval="[(4, ref('group_hostel_user'))]"/>
    <field name="users" eval="[(4, ref('base.user_admin'))]"/> </record>

如果我们升级附加模块，这两个记录将被加载。要在 UI 中看到这些组，您需要激活开发者模式。然后您可以通过设置 | 用户 | 组菜单选项看到它们，如下所示：

图 10.1 – 新增的安全组

重要信息

当您添加一个新的模型时，管理员用户没有对该模型的访问权限。这意味着管理员用户无法看到为该模型添加的菜单和视图。要显示它，您必须首先向该模型添加访问规则，我们将在“向模型添加安全访问”配方中完成此操作。请注意，您可以用超级用户身份访问新添加的模型；有关更多信息，请参阅第三章，“以超级用户身份访问 Odoo”配方，创建 Odoo 附加模块。

它是如何工作的...

附加模块被组织成功能区域，或主要的应用程序，例如会计和财务、销售或人力资源。这些由清单文件中的category键定义。

如果类别名称尚不存在，它将被自动创建。为了方便，还会为新的类别名称生成一个base.module_category_<category_name_in_manifest> XML ID，将空格替换为下划线。这对于将安全组与应用程序类别相关联很有用。

在我们的示例中，我们使用了base.module_category_hostel XML 标识符。

按照惯例，包含安全相关元素的数据文件应放置在security子目录中。

清单文件还必须用于注册安全文件。在模块清单的data键中指定文件的顺序至关重要，因为您不能在其他视图或ACL文件中使用对安全组的引用，直到该组被创建。建议将安全数据文件放在第一位，然后是 ACL 文件和其他用户界面数据文件。

在我们的示例中，我们使用<record>标签创建了组，这将创建res.groups模型的记录。res.group模型最重要的列如下：

name: 这是该组的显示名称。
category_id: 这是对应用程序类别的引用，并用于在用户表单中组织组。
implied_ids: 这些是从中继承权限的其他组。
users: 这是属于此组的用户列表。在新增的附加模块中，我们通常希望管理员用户属于应用程序的管理员组。

第一个安全组使用implied_ids作为base.group_user组。这是Employee用户组，并且是所有后端用户预期共享的基本安全组。

第二个安全组在users字段上设置值，将其分配给具有base.user_admin XML ID 的管理员用户。

属于安全组的用户将自动属于其暗示的组。例如，如果您将宿舍管理员组分配给任何用户，该用户也将包括在用户组中。这是因为宿舍管理员组在其implied_ids列中包含用户组。

此外，安全组的访问权限是累积的。如果用户所属的任何组（直接或间接）授予他们权限，则用户具有权限。

一些安全组在用户表单中以选择框的形式显示，而不是单独的复选框。这种情况发生在涉及到的组属于同一应用类别，并且通过implied_ids线性互联时。例如，组 A 暗示组 B，而组 B 暗示组 C。如果一个组没有通过implied_ids与其他组关联，则会出现复选框而不是选择框。

注意

注意，前面字段中定义的关系也有反向关系，可以在相关模型中编辑，例如安全组和用户。

使用相关记录的 XML ID 和一些特殊语法可以在引用字段上设置值，例如category_id和implied_ids。这种语法在第六章，管理模块数据中详细解释。

参见

要了解如何通过 超级用户 访问新添加的模型，请参阅 第三章 中的 作为超级用户访问 Odoo 菜谱，创建 Odoo 附加模块。

为模型添加安全访问权限

对于附加模块添加新模型是很常见的。例如，在 第三章 的 创建 Odoo 附加模块 中，我们添加了一个新的宿舍模型。在开发过程中，很容易忽略为新模型创建安全访问权限，你可能会发现很难看到创建的菜单和视图。这是因为，从 Odoo 版本 12 开始，管理员用户默认没有对新模型的访问权限。要查看新模型的视图和菜单，你需要添加安全 ACLs。

然而，没有 ACLs 的模型在加载时将触发一个警告日志消息，通知用户缺少 ACL 定义：

WARNING The model hostel.hostel has no access rules, consider adding one example, access_hostel_hostel, access_hostel_hostel, model_hostel_hostel, base.group_user,1,0,0,0

你也可以以超级用户身份访问新上传的模型，这绕过了所有安全要求。有关更多信息，请参阅 第三章 中的 作为超级用户访问 Odoo 菜谱，创建 Odoo 附加模块。管理员可以访问超级用户功能。因此，为了使非管理员用户可以使用新模型，我们必须建立它们的访问控制列表，以便 Odoo 了解如何访问它们以及每个用户组被允许执行的活动。

准备工作

我们将继续使用之前教程中的 my_hostel 模块，并为其添加缺失的访问控制列表（ACLs）。

如何操作...

my_hostel 应该已经包含创建 hostel.hostel 模型的 models/hostel.py Python 文件。现在我们将通过以下步骤添加一个描述此模型安全访问控制的数据文件：

编辑 __manifest__.py 文件以声明一个新的数据文件：

    data: [
        # ...Security Groups
        'security/ir.model.access.csv',
        # ...Other data files
    ]

在模块中添加一个新的 security/ir.model.access.csv 文件，包含以下行：

id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink
acl_hostel,hostel_hostel_default,model_hostel_hostel,base_group_user,1,0,0,0
acl_hostel_manager,hostel_manager,model_hostel_hostel,group_hostel_manager,1,1,1,1

然后，我们应该升级模块，以便将这些 ACL 记录添加到我们的 Odoo 数据库中。更重要的是，如果我们使用 demo 用户登录演示数据库，我们应该能够访问 我的宿舍 菜单选项而不会收到任何安全错误。

它是如何工作的...

安全 ACLs 存储在核心 ir.model.access 模型中。我们只需要添加描述每个用户组预期访问权限的记录。

任何类型的数据文件都可以，尽管最流行的是 CSV 文件。文件可以放置在附加模块目录中的任何位置；然而，通常会将所有与安全相关的文件保存在一个安全子文件夹下。

这个新的数据文件在教程的第一阶段添加到清单中。下一步是包含解释安全访问控制规则的文件。CSV 文件必须以将要导入条目的模型命名，所以我们选择的名称不仅仅是一种约定；这是必需的。有关更多信息，请参阅第六章，管理模块数据。

如果模块还创建了新的安全组，其数据文件应在 ACLs 数据文件之前在清单中声明，因为您可能希望将其用于 ACLs。它们必须在处理 ACL 文件之前已经创建。

CSV 文件中的列如下：

id：这是此规则的内部 XML ID 标识。模块内的任何唯一名称都是可接受的，但最佳实践是使用access_<model>_<group>。
name：这是访问规则的标题。使用access.<model>.<group>名称是一种常见的做法。
model_id:id：这是模型的 XML ID。Odoo 自动为具有model_<name>格式的模型分配此类 ID，使用模型的重音符_name而不是点。如果模型是在不同的附加模块中创建的，则需要一个包含模块名称的完全限定 XML ID。
group_id:id：这是用户组的 XML ID。如果为空，则适用于所有用户。基础模块提供了一些基本组，例如base.group_user适用于所有员工和base.group_system适用于管理员用户。其他应用程序可以添加它们自己的用户组。
perm_read：前一个组的成员可以读取模型的记录。它接受两个值：0或1。使用0来限制模型上的读访问，使用1来提供读访问。
perm_write：前一个组的成员可以更新模型的记录。它接受两个值：0或1。使用0来限制模型上的写访问，使用1来提供写访问。
perm_create：前一个组的成员可以添加此模型的新记录。它接受两个值：0或1。使用0来限制模型上的创建访问，使用1来提供创建访问。
perm_unlink：前一个组的成员可以删除此模型的记录。它接受两个值：0或1。使用0来限制模型上的解除链接访问，使用1来提供解除链接访问。

我们使用的 CSV 文件为员工 | Employee标准安全组添加了只读访问权限，并为管理 | 设置组提供了完全写访问权限。

base.group_user 特别重要，因为 Odoo 标准应用添加的用户组都继承自它。这意味着，如果我们需要一个新的模型对所有后端用户都可用，无论他们使用的是哪个具体的应用程序，我们应该将这个权限添加到员工组。

base.group_user尤其重要，因为它继承自 Odoo 标准应用引入的用户组。这意味着，如果我们想让新的模型对所有后端用户可访问，而不管他们使用的是哪个应用，我们需要将其添加到员工组。

在调试模式下，您可以通过导航到设置 | 技术 | 安全 | 访问控制列表来查看生成的 ACLs，如下面的截图所示：

图 10.2 – ACL 列表视图

有些人发现使用此用户界面定义 ACLs 然后使用导出功能生成 CSV 文件更容易。

参见

由于绕过了所有安全规则，您也可以通过超级用户访问新添加的模型。有关更多信息，请参阅第三章中的作为超级用户访问 Odoo配方，创建 Odoo 附加模块。

限制模型中字段的访问

在其他情况下，我们可能需要额外的细粒度访问控制，以及限制对模型中单个字段访问的能力。

使用groups属性，可以限制对字段的访问，使其仅限于特定的安全组。本配方将演示如何向 Hostels 模型添加具有受限访问权限的字段。

准备工作

我们将继续使用前一个教程中的my_hostel模块。

如何操作...

要添加一个仅限于特定安全组访问权限的字段，请执行以下步骤：

编辑模型文件以添加字段：

is_public = fields.Boolean(groups='my_hostel.group_hostel_manager')
notes = fields.Text(groups='my_hostel.group_hostel_manager')

在 XML 文件中编辑视图以添加字段：

<field name="is_public" />
<field name="notes" />

就这样。现在，升级附加模块以使模型中的更改生效。如果你使用没有系统配置访问权限的用户登录，例如在包含演示数据的数据库中使用demo，宿舍表单将不会显示该字段。

它是如何工作的...

包含groups属性的域在确定用户是否属于属性中指定的任何安全组时会被以不同的方式处理。如果一个用户不是某个特定组的成员，Odoo 将会从 UI 中移除该字段，并限制对该字段的 ORM 操作。

注意，这种安全性并非表面化。字段不仅在 UI 中被隐藏，在read和write等其他 ORM 操作中也不对用户可用。对于XML-RPC或JSON-RPC调用也是如此。

在使用这些字段在业务逻辑或 UI 事件变更（@api.onchange方法）时请小心；它们可能会对没有访问权限的用户引发错误。一个解决方案是使用权限提升，例如sudo()模型方法或计算字段的compute_sudo字段属性。

groups值是一个包含逗号分隔的有效 XML ID 列表的字符串，用于安全组。找到特定组的 XML ID 的最简单方法是激活开发者模式，导航到该组的表单，在设置 | 用户 | 组，然后从调试菜单中访问查看元数据选项，如图下所示：

图 10.3 – 查看组 XML ID 的菜单

你也可以通过利用形成组的<record>标签通过代码查看安全组的 XML ID。然而，查看信息，如图下所示，是找出组 XML ID 的最简单方法。

参见

请参阅第九章，后端视图，以获取有关如何使用标准隐藏和显示字段的更多信息。

要深入了解业务逻辑层，请参阅第五章，基本 服务器端开发。

使用记录规则限制记录访问

每个应用程序的基本要求是能够限制在特定模型上向每个用户暴露哪些记录。

这是通过使用记录规则来实现的。记录规则是在模型上指定的一个域过滤器表达式，随后应用于受影响的用户执行的所有数据查询。

例如，我们将向Hostel模型添加一个记录规则，以便Employee组中的用户只能访问公共宿舍。

准备工作

我们将继续使用之前配方中的my_hostel模块。

如何实现...

可以通过使用数据 XML 文件来添加记录规则。为此，请执行以下步骤：

确保由清单data键引用security/security_rules.xml文件：

    'data': [
        'security/security_rules.xml',
        # ...
    ],

我们应该有一个包含创建安全组的<odoo>部分的security/security_rules.xml数据文件：

图 10.4 – 宿舍用户的记录规则

升级附加模块将在 Odoo 实例中加载记录规则。如果你正在使用演示数据，你可以通过默认的demo用户来测试它，为演示用户赋予宿舍用户权限。如果你没有使用演示数据，你可以创建一个新的用户并赋予其宿舍用户权限。

工作原理...

记录规则只是放置在ir.rule核心模型中的数据记录。虽然包含它们的文件可以位于模块中的任何位置，但security子文件夹是首选位置。通常包含安全组和记录规则的单一 XML 文件。

与组不同，标准模块中的记录规则被导入具有noupdate="1"属性的odoo部分。因为某些记录在模块更新后不会被重新加载，所以手动自定义它们是安全的，并且可以在进一步的升级中幸存。

为了与标准模块保持一致，我们的记录规则也应该包含在<odoo> noupdate="1">部分中。

记录规则可以通过设置| 技术 | 安全 | 记录规则菜单选项在 GUI 中查看，如下面的截图所示：

图 10.5 – 宿舍模型的 ACLs

在此示例中使用了以下最重要的记录规则字段：

name): 规则的描述性标题。
model_id): 规则应用的模型的引用。
groups): 受规则影响的权限组。如果没有提及权限组，则规则被认为是全局的，并且执行方式不同（继续阅读以了解更多关于这些组的信息）。
domain): 用于过滤记录的域表达式。规则仅适用于这些过滤记录。

我们创建的第一个记录规则是为Hostel User安全组。它使用[('is_public', '=', True)]域表达式来选择仅公开可用的宿舍。因此，具有Hostel User安全组的用户将只能看到公共宿舍。

注意

记录规则中使用的域表达式是在服务器上使用 ORM 对象执行的。因此，可以在左侧的字段（第一个元组成员）上使用点表示法。例如，[('country_id.code', '=', 'IN')]域表达式将仅返回包含印度国家的条目。

由于记录规则主要基于当前用户，您可以在域的右侧（第三个元组元素）使用user记录集。因此，如果您想显示当前用户的公司的记录，您可以使用[('company_id', '=', user.company_id.id)]域。或者，如果您想显示由当前用户创建的记录，您可以使用[('user_id', '=', user.id)]域。

我们希望Hostel Manager安全组能够访问所有宿舍，无论它们是公开的还是私人的。因为它是从Hostel User组派生的，所以它将只能看到公共宿舍，直到我们干预。

非全局记录规则使用OR逻辑运算符连接；每个规则添加访问权限，永远不会移除此访问权限。为了使Hostel Manager安全组能够访问所有宿舍，我们必须向其中添加一个记录规则，以便它可以添加对所有宿舍的访问权限，如下所示：

[('is_public', 'in', [True, False])]

我们选择在这里以不同的方式操作，并使用[(1, '=', 1)]特殊规则来无条件地给予对所有宿舍记录的访问权限。虽然这看起来可能是多余的，但请记住，如果我们不这样做，Hostel User规则可以被定制，从而让某些宿舍对设置用户不可达。域是特殊的，因为域元组的第一个元素必须是字段名；这种情况是两种情况之一，其中这不是真的。[(1, '=', 0)]的特殊域永远不会为真，但在记录规则的情况下也不是非常有用。这是因为此类规则用于限制对所有记录的访问。同样的事情也可以通过访问列表实现。

重要信息

如果您已激活SUPERUSER模式，则记录规则将被忽略。在测试您的记录规则时，请确保您使用另一个用户进行测试。

还有更多...

当记录规则未分配给安全组时，它被标记为全局，并且与其他规则的处理方式不同。

AND运算符。它们用于标准模块中创建多公司安全访问，以便每个用户只能看到他们自己业务的数据。

总结来说，标准非全局记录规则与 OR 运算符结合，如果任何规则授予访问权限，则记录可访问。当使用 AND 运算符时，全局记录规则会对传统记录规则提供的访问权限添加限制。常规记录规则不能覆盖全局记录规则施加的限制。

使用安全组激活功能

一些功能可以通过安全组进行限制，以便只有属于这些组的人才能访问。安全组可以继承其他组，从而授予它们权限。

这两个功能用于在 Odoo 中提供功能切换功能。安全组也可以用来为某些用户或整个 Odoo 实例激活或禁用功能。

本食谱演示了如何向配置设置中添加选项，并展示了启用额外功能的两种方法：通过安全组使其可见或通过安装附加模块添加它们。

对于第一种情况，我们将使宿舍开始日期成为一个可选的附加功能；对于第二种情况，例如，我们将提供一个安装笔记模块的选项。

准备工作

本教程使用 my_hostel 模块，该模块在 第三章，创建 Odoo 附加模块 中进行了描述。我们将需要安全组来工作，因此您也需要遵循本章中的 向模型添加安全访问 食谱。

在本食谱中，一些标识符需要引用附加模块的技术名称。我们将假设这是 my_hostel。如果您使用的是不同的名称，请将 my_hostel 替换为您的附加模块的实际技术名称。

如何操作...

要添加配置选项，请按照以下步骤操作：

要添加必要的依赖项和新 XML 数据文件，请像这样编辑 __manifest__.py 文件并确保它依赖于 base_setup：

{  'name': 'Cookbook code',
    'category': 'Hostel',
    'depends': ['base_setup'],
    'data': [
        'security/ir.model.access.csv',
        'security/groups.xml',
        'views/hostel_hostel.xml',
        'views/res_config_settings.xml',
    ],
}

要添加用于功能激活的新安全组，请编辑 security/groups.xml 文件并添加以下记录：

    <record id="group_start_date" model="res.groups">
        <field name="name">Hostel: Start date feature</field>
        <field name="category_id" ref="base.module_category_hidden" />
    </record>

要使宿舍开始日期仅在启用此选项时可见，请编辑 models/hostel.py 文件中的字段定义：

class HostelHostel(models.Model):
    # ...
    date_start = fields.Date(
        'Start Date',
        groups='my_hostel.group_start_date',    )

编辑 models/__init__.py 文件以添加一个新的 Python 文件用于配置设置模型：
```
from . import hostel
from . import res_config_settings
```

要通过添加新选项来扩展核心配置向导，请添加包含以下代码的 models/res_config_settings.py 文件：

from odoo import models, fields
class ConfigSettings(models.TransientModel):
    _inherit = 'res.config.settings'
    group_start_date = fields.Boolean(
            "Manage Hostel Start dates",
            group='base.group_user',
            implied_group='my_hostel.group_start_dates',
    )
    module_note = fields.Boolean("Install Notes app")

要在用户界面中提供这些选项，请添加 views/res_config_settings.xml，它扩展了设置表单视图：

<?xml version="1.0" encoding="utf-8"?>
<odoo>
    <record id="view_general_config_hostel" model="ir.ui.view">
        <field name="name">Configuration: add Hostel options</field>
        <field name="model">res.config.settings</field>
        <field name="inherit_id" ref="base_setup.res_config_settings_view_form" />
        <field name="arch" type="xml">
            <div id="business_documents" position="before">
             <h2>Hostel</h2>
                <div class="row mt16 o_settings_container">
                    <!-- Add Step 7 and 8 goes here -->
                </div>
            </div>
        </field>
    </record>
</odoo>

在设置表单视图中，添加添加开始日期功能的选项：

<!-- Start Dates option -->
<div class="col-12 col-lg-6 o_setting_box">
    <div class="o_setting_left_pane">
        <field name="group_start_date" class="oe_inline"/>
    </div>
    <div class="o_setting_right_pane">
        <label for="group_start_date"/>
        <div class="text-muted">
            Enable Start date feature on hostels
        </div>
    </div>
</div>

在设置表单视图中，添加安装笔记模块的选项：

<!-- Note module option -->
<div class="col-12 col-lg-6 o_setting_box">
    <div class="o_setting_left_pane">
        <field name="module_note" class="oe_inline"/>
    </div>
    <div class="o_setting_right_pane">
        <label for="module_note"/>
        <div class="text-muted">
            Install note module
        </div>
    </div>
</div>

在升级附加模块后，两个新的配置选项应在设置 | 常规设置 下可用。屏幕应如下所示：

图 10.6 – 常规设置中的宿舍配置

如前一个截图所示，您将在宿舍部分看到新的设置。第一个选项，管理宿舍开始日期，将为宿舍记录启用开始日期功能。第二个选项，安装笔记应用，将安装 Odoo 的笔记应用。

它是如何工作的...

核心的base模块提供了res.config.settings模型，该模型提供了激活选项背后的业务逻辑。base_setup附加模块使用res.config.settings模型提供一些基本配置选项，这些选项可以在新数据库中提供。它还使设置 | 常规设置菜单可用。

base_setup模块将res.config.settings适配到中央管理仪表板，因此我们需要扩展它以添加配置设置。

如果我们决定为宿舍应用创建一个特定的设置表单，我们仍然可以从res.config.settings模型继承，使用不同的_name，然后为新的模型提供菜单选项和表单视图，仅针对这些设置。我们已经在第八章的添加自己的设置选项食谱中看到了这种方法，高级服务器端开发技术。

我们通过两种方式激活了这些功能：通过激活一个安全组并使功能对用户可见，以及通过安装一个提供此功能的附加模块。基本的res.config.settings模型提供了处理这两种情况所需的逻辑。

本教程的第一步是将base_setup附加模块添加到依赖项中，因为它为我们想要使用的res.config.settings模型提供了扩展。它还添加了一个额外的 XML 数据文件，我们将需要将其添加到常规设置表单中。

在第二步中，我们创建了一个新的安全组，宿舍：开始日期功能。需要激活的功能应该只对该组可见，因此它将在该组启用之前隐藏。

在我们的示例中，我们希望宿舍开始日期仅在相应的配置选项启用时才可用。为了实现这一点，我们可以使用字段的groups属性，使其仅对这一安全组可用。我们在模型级别做了这件事，以便它自动应用于所有使用该字段的 UI 视图。

最后，我们扩展了res.config.settings模型以添加新的选项。每个选项都是一个布尔字段，其名称必须以group_或module_开头，根据我们希望它执行的操作。

group_选项字段应该有一个implied_group属性，并且应该是一个包含逗号分隔的安全组 XML ID 列表的字符串，当它启用时将激活这些安全组。XML ID 必须是完整的，包括模块名称、点以及标识符名称；例如，module_name.identifier。

我们还可以提供一个 group 属性来指定哪些安全组将启用该功能。如果没有定义任何组，它将为所有基于员工的组启用。因此，相关的组不会应用于门户安全组，因为这些组不像其他常规安全组那样从员工基本安全组继承。

激活背后的机制相当简单：它将 group 属性中的安全组添加到 implied_group 中，从而使相关的功能对相应的用户可见。

module_ 选项字段不需要任何额外的属性。字段名剩余部分标识了当此选项被激活时将安装的模块。在我们的示例中，module_note 将安装 Note 模块。

重要信息

取消勾选将不会警告即卸载模块，这可能导致数据丢失（模型、字段和模块数据将被删除作为后果）。为了避免意外取消勾选，secure_uninstall 社区模块（来自 github.com/OCA/server-tools）在用户卸载附加模块之前会提示用户输入密码。

还有更多...

配置设置也可以有以 default_ 前缀命名的字段。当其中之一有值时，ORM 将将其设置为全局默认值。settings 字段应该有一个 default_model 属性来标识受影响的模型，并且 default_ 前缀后面的字段名标识了将设置默认值的 model 字段。

此外，没有提到这三个前缀之一的字段可以用于其他设置，但您需要实现填充它们值的逻辑，使用以 get_default_ 命名的前缀方法，并使用以 set_ 命名的前缀方法在它们的值被编辑时执行操作。

对于那些想深入了解配置设置细节的人来说，请查看 Odoo 的源代码在 ./odoo/addons/base/models/res_config.py，那里有大量的注释。

以超级用户身份访问记录集

在之前的菜谱中，我们探讨了包括访问规则、安全组和记录规则在内的安全策略。您可以通过这些方法避免未经授权的访问。然而，在某些复杂的企业场景中，您可能需要查看或编辑记录，即使用户没有访问权限。例如，假设公共用户没有访问线索记录的权限，但用户可能通过提交网站表单在后台生成线索记录。

您可以通过使用 sudo() 以超级用户身份访问记录集。我们在 第八章 的 高级服务器端开发技术 菜谱中介绍了 sudo()。在这里，我们将看到即使您已设置 ACL 规则或将安全组分配给字段，您仍然可以使用 sudo() 获取访问权限。

如何操作...

我们将使用之前教程中的相同my_hostel模块。我们已经有了一个只读访问权限的 ALC 规则，适用于普通用户。我们将添加一个新字段，并使用安全组，以便只有管理员用户可以访问它。之后，我们将修改普通用户的字段值。按照以下步骤实现：

将新字段添加到hostel.hostel模型：

details_added = fields.Text(
      string="Details",
      groups='my_hostel.group_hostel_manager')

将字段添加到表单视图：
```
<field name="details_added"/>
```

将add_details()方法添加到hostel.hostel模型：

    def add_details(self):
        self.ensure_one()
        message = "Details are(added by: %s)" % self.env.user.name
        self.sudo().write({
            'details_added': message
        })

将按钮添加到表单视图，以便我们可以从用户界面触发我们的方法。这应该放在<header>标签内部：
```
<button name="add_details"
    string="Add Details"
    type="object"/>
```

重新启动服务器并更新模块以应用这些更改。

它是如何工作的...

在步骤 1和步骤 2中，我们向模型和表单视图添加了一个名为details_added的新字段。请注意，我们在 Python 中将my_hostel.group_hostel_manager组放在字段上，因此此字段只能由管理员用户访问。

在下一步中，我们添加了add_details()方法。我们更新了此方法体内details_added()字段的值。请注意，我们在调用写入方法之前使用了sudo()。

最后，我们在表单视图中添加了一个按钮，用于从用户界面触发该方法。

为了测试这个实现，您需要使用非管理员用户登录。如果您已经用演示数据加载了数据库，您可以使用演示用户登录，然后点击add_details()方法将被调用，这将把消息写入details_added字段，即使用户没有适当的权限。您可以通过管理员用户检查字段的值，因为此字段将从演示用户那里隐藏。

当点击add_details()方法作为参数时，使用self。在我们将值写入宿舍记录集之前，我们使用了self.sudo()。这返回相同的记录集，但具有超级用户权限。这个记录集将具有su=True环境属性，并且将绕过所有访问规则和记录规则。正因为如此，非管理员用户将能够写入宿舍记录。

根据组隐藏视图元素和菜单

在之前的菜谱中，我们介绍了如何使用 Python 字段声明中的组参数来隐藏某些用户的字段。在用户界面中隐藏字段的另一种方法是向视图规范中的 XML 元素添加安全组。您还可以通过使用菜单来隐藏特定用户的安全组。

准备工作

对于这个菜谱，我们将重用前一个菜谱中的 my_hostel 扩展模块。在前一个菜谱中，我们向 <header> 标签添加了一个按钮。我们将通过向其添加组属性来隐藏几个用户的整个头部。

添加 hostel.room.category 模型的模型、视图和菜单。我们将隐藏对用户的类别菜单。请参阅 第四章 应用模型，了解如何添加模型视图和菜单。

如何操作...

按照以下步骤根据安全组隐藏元素：

向 <header> 标签添加 groups 属性以隐藏它对其他用户：
```
...
<header groups="my_hostel.group_hostel_manager">
...
```

向 <menuitem> 宿舍类别添加 groups 属性，以便它仅对图书管理员用户显示：

    <menuitem name="Hostel Room Categories"
        id="hostel_room_category_menu"
        parent="hostel_base_menu"
        action="hostel_room_category_action"
        groups="my_hostel.group_hostel_manager"/>

重新启动服务器并更新模块以应用这些更改。

它是如何工作的...

在 步骤 1 中，我们将 groups="my_hostel.group_hostel_manager" 添加到 <header> 标签中。这意味着整个头部部分将仅对宿舍用户和宿舍管理员可见。没有 group_hostel_manager 的普通后端用户将看不到头部部分。

在 步骤 2 中，我们将 groups="my_hostel.group_hostel_manager" 属性添加到 menuitem。这意味着此菜单仅对宿舍用户可见。

您几乎可以在任何地方使用 groups 属性，包括 <field>、<notebook>、<group> 和 <menuitems>，或者在任何视图架构的标签上。如果用户没有那个组，Odoo 将隐藏这些元素。您可以在网页和 QWeb 报告 中使用相同的组属性，这些将在 第十二章 自动化、工作流、电子邮件和打印 和 第十四章 CMS 网站开发 中介绍。

如我们在本章的 以超级用户访问记录集 菜谱中看到的，我们可以通过在 Python 字段定义中使用 groups 参数来隐藏某些用户的部分字段。请注意，在字段上使用安全组和在视图中使用 Python 安全组之间存在很大差异。Python 中的安全组提供真正的安全性；未经授权的用户甚至无法通过 ORM 或 RPC 调用来访问字段。然而，视图中的组只是为了提高可用性。通过 XML 文件中的组隐藏的字段仍然可以通过 RPC 或 ORM 访问。

参见

请参阅 第四章 应用模型，了解如何添加模型视图和菜单。

第十一章：国际化

Odoo 支持多种语言，并允许用户使用他们最舒适的语言。内置的 Odoo i18n 功能有助于实现这一点。通过字符串翻译，Odoo 还支持日期和时间格式。

在本章中，您将了解如何将翻译文件上传到您的模块并启用各种语言。由于国家多样性和本地语言的普遍性，用户通常发现当系统以他们的母语呈现时更容易与之连接。为了适应这一点，Odoo 提供了一种功能，可以将软件文本翻译成用户的偏好语言。这一功能通过确保界面对各种语言背景的个人都是可访问和可理解的，从而提高了软件在不同地区和人口统计学中的采用率和可用性。利用这些新功能将增强 Odoo 用户体验。

本章将涵盖以下食谱：

设置语言安装和用户偏好设置
设置与语言相关的选项
使用网络客户端用户界面进行文本翻译
将翻译导出为文件
使用gettext工具使翻译更容易
将翻译文件导入 Odoo
修改网站的定制语言 URL 代码

许多这些食谱可以从网络客户端用户界面或从命令行完成。 wherever possible，我们将了解如何使用这两种选项。Odoo 使用 Transifex(Odoo)和 Weblate (OCA)翻译平台。

设置语言安装和用户偏好设置

Odoo 可以本地化以适应各种语言和地区设置，包括日期和数字格式。

初始安装的唯一语言是标准英语语言。我们需要安装各种地区和语言，以便人们可以使用它们。本食谱描述了如何实现用户偏好，以及如何设置它们。

如何操作...

激活开发者模式并按照以下步骤在 Odoo 实例中安装新语言：

前往设置 | 通用设置 | 语言。在这里，您将看到添加语言链接，如以下截图所示。点击该链接；将打开一个对话框，您可以在其中加载语言：

图 11.1 – 通用设置中的语言选项

选择您想要加载的语言：

图 11.2 – 加载语言的对话框

点击添加将加载所选语言，并将确认对话框打开，如下所示：

图 11.3 – 显示已加载语言的对话框

新语言也可以从命令行安装。前述步骤的等效命令如下：
```
$ ./odoo-bin -d mydb --load-language=es_ES
```
要设置用户使用的语言，请转到设置 | 用户与公司 | 用户，然后在用户表单的偏好选项卡中设置语言字段值：

图 11.4 – 设置语言的用户表单

通过偏好菜单项，用户可以轻松地自行更改这些变量。他们可以通过点击网页客户端窗口右上角的用户名来访问它：

图 11.5 – 设置语言的偏好选项

它是如何工作的...

用户可以有自己的语言和时区偏好。语言设置用于将用户界面文本翻译成所选语言，并应用于浮点数和货币字段的地方惯例。

在用户可以选择语言之前，必须使用添加语言选项安装该语言。可以通过转到开发者模式下的设置 | 翻译 | 语言菜单选项来查看可用的语言列表。带有活动标志设置的语言已安装。

每个 Odoo 附加模块都负责提供翻译资源，这些资源应放置在i18n子目录中。每种语言的数据应在一个.po文件中。在我们的例子中，西班牙语的翻译数据是从es_ES.po数据文件中加载的。

Odoo 还支持es.po文件的概念，用于西班牙语，以及es_MX.po文件，用于墨西哥西班牙语，然后es.po被检测为es_MX.po的基础语言。当安装墨西哥西班牙语时，将加载两个数据文件；首先加载基础语言的一个，然后是特定语言的一个。因此，在我们的情况下，墨西哥西班牙语的翻译文件只需包含该语言变体独有的字符串。

i18n子目录还应该有一个<module_name>.pot文件，提供翻译模板并包含所有可翻译的字符串。本章的将翻译字符串导出到文件配方解释了如何导出可翻译字符串以生成此文件。

在 Odoo 的早期版本中，当安装了额外的语言时，相应的资源会从所有已安装的附加模块中加载，并存储在翻译术语模型中。其数据可以在设置 | 翻译 | 应用程序术语 | 翻译术语菜单选项中查看（并编辑）（注意，此菜单仅在开发者模式下可见）。

从 Odoo 版本 17 开始，您将无法找到此菜单，因为翻译术语现在作为本地术语存储。现在任何可翻译的字段都存储表示所有翻译语言值的 JSON 数据。例如，产品名称的翻译现在直接存储在name字段中。翻译过程没有改变——您只是无法看到带有所有已翻译术语列表的设置 | 翻译 | 应用程序术语 | 已翻译术语菜单项。

当安装新的附加模块或升级现有附加模块时，也会加载已安装语言的翻译文件。

还有更多...

通过再次选择语言旁边的刷新符号，可以在不升级附加模块的情况下刷新翻译文件。如果您更改了翻译文件，但不想处理更新模块（及其所有依赖项），则可以这样做。

如果覆盖现有术语复选框留空，则只会加载新翻译的字符串。因此，更改后的翻译字符串不会被加载。如果您想同时加载现有翻译并覆盖当前加载的翻译，请勾选该框。请注意，如果有人通过界面手动更改翻译，这可能会引起潜在问题。

覆盖现有术语复选框存在，因为我们可以通过转到设置 | 翻译 | 应用程序术语 | 已翻译术语菜单项或使用调试菜单中的技术翻译快捷选项来编辑特定的翻译。以这种方式添加或修改的翻译不会覆盖，除非通过启用覆盖现有术语复选框重新加载语言。

了解附加模块也可以有一个i18n_extra子目录，其中包含额外的翻译，这可能很有用。首先，下载i18n子目录中的.po文件。然后，Odoo ORM 下载基本语言的文件，然后是语言变体的文件。随后，下载i18n_extra子目录中的.po文件，首先是基本语言，然后是语言变体。最终加载的字符串翻译是最终具有优先级的翻译。

设置与语言相关的选项

只要用户使用正确的语言，区域设置就应该正确，因为它们带有合适的默认值。

尽管如此，您可能仍然想要更改语言的设置。例如，您可以选择在更改美国日期和数字格式以更好地满足您的需求的同时，使用用户界面默认的英语语言设置。

此外，日期和数字格式等区域设置由语言及其变体（例如es_MX代表墨西哥西班牙语）提供。

准备工作

我们需要开启开发者模式。如果之前尚未启用，请按照第一章中安装 Odoo 开发环境的激活 Odoo 开发者工具配方中描述的方式进行操作。

如何操作...

按照以下步骤更改语言的区域设置：

选择设置 | 翻译 | 语言菜单选项以查看已安装的语言及其选项。当您点击一个已安装的语言时，将打开一个包含必要选项的表单：

图 11.6 – 配置语言设置的表单

编辑语言设置。要将日期更改为 ISO 格式，将%Y-%m-%d更改为。要将数字格式更改为使用逗号作为小数分隔符，相应地修改小数分隔符和千位分隔符字段。

它是如何工作的...

用户语言在用户偏好设置中选中，并在登录和启动新的 Odoo 用户会话时放置在lang上下文键中。通过将源文本翻译成用户语言，并根据语言当前的区域设置格式化日期和数字，相应地准备输出。

使用 Web 客户端用户界面进行文本翻译

翻译的最简单方法是使用 Web 客户端提供的翻译功能。这些翻译字符串存储在数据库中，以后可以导出为.po文件，既可以包含在附加模块中，也可以手动导入。

文本字段可以有可翻译的内容，这意味着它们的值将取决于当前用户的语言。我们还将了解如何设置这些字段的语言相关值。

准备工作

我们需要启用开发者模式。如果没有启用，请按照第一章中安装 Odoo 开发环境的激活 Odoo 开发者工具配方所示进行操作。

如何操作...

我们将通过使用用户组功能作为示例来演示如何通过 Web 客户端翻译术语：

导航到您想要翻译的屏幕。例如，我们将通过设置 | 用户和公司 | 组菜单项打开组视图：

图 11.7 – 组的翻译

在表单视图中打开其中一个组记录，然后点击编辑：

图 11.8 – 字段值的翻译

注意，名字字段在右侧有一个特殊图标。这表示它是一个可翻译字段。点击此图标将打开一个包含不同已安装语言的翻译列表。这允许我们为这些语言中的每一个设置翻译：

图 11.9 – 字段值的翻译

工作原理...

所有翻译术语都保存在任何模式/表的名字字段中。在我们的例子中，res_groups 表；当你检查名字字段中存储的信息时，它将被保存为一个字典，其中键是语言代码，值是翻译短语：

图 11.10 – 字段值的翻译

将翻译字符串导出到文件

翻译字符串可以带或不带所选语言的翻译文本进行导出。这可以是将 i18n 数据包含在模块中，或者稍后使用文本编辑器或可能使用专用工具进行翻译。

我们将通过我们的自定义 My Hostel 模块演示如何进行此操作，因此请随意将 My Hostel 替换为您自己的模块。

准备工作

我们需要启用开发者模式。如果尚未启用，请按照在 第一章 中演示的 激活 Odoo 开发者工具 菜谱进行操作，安装 Odoo 开发环境。

如何操作...

要导出 my_hostel 模块的翻译术语，请按照以下步骤操作：

在网络客户端用户界面中，从设置顶部菜单中选择翻译 | 导入/导出 | 导出翻译 菜单选项。
在 .po 格式下，并且一次导出单个扩展模块 – my_hostel 是 Discuss 应用程序的技术名称），在我们的例子中：

图 11.11 – 导出翻译术语的对话框

在 Odoo 版本 17 中，你将在导出设置中找到一个名为 导出类型 的新选项，它包含两个选项：模块和模型。
将模块类型设置为模型将提供新的选项来选择具有筛选选项的特定模型，用户可以使用该选项仅导出基于特定筛选的记录：

图 11.12 – 导出翻译术语的对话框

一旦导出过程完成，将显示一个新窗口，其中包含下载文件的链接和一些额外的建议。
要从 Odoo 命令行界面导出 my_hostel 扩展模块的翻译模板文件，请输入以下命令：
```
$ ./odoo-bin -d mydb --i18n-export=my_hostel.pot --modules=my_hostel
es_ES for Spanish, for example – from the Odoo command-line interface, enter the following command:
```
$ ./odoo-bin -d mydb --i18n-export=es_ES.po --modules=my_hostel

--language=es_ES

$ mv es_ES.po ./addons/my_hostel/i18n

工作原理...

导出翻译功能从目标模块中提取可翻译的字符串，然后创建一个包含翻译术语的文件。这可以从 Web 客户端和命令行界面完成。

当从 Web 客户端导出时，我们可以选择导出空翻译模板——即包含要翻译的字符串和空翻译的文件，或者导出一个语言，结果是一个包含要翻译的字符串和所选语言的翻译的文件。

可用的文件格式是 CSV、PO 和 TGZ。TGZ 文件格式导出一个包含<name>/i18n/目录结构的压缩文件，其中包含 PO 或 POT 文件。

CSV 格式在通过电子表格进行翻译时很有用，但在附加模块中使用的格式是 PO 文件。这些文件应放置在i18n子目录中。一旦安装了相应的语言，它们就会自动加载。在导出这些 PO 文件时，我们应该一次只导出一个模块。PO 文件也是翻译工具（如 Poedit）支持的流行格式之一。

翻译也可以通过使用--i18n-export选项直接从命令行导出。这个示例展示了如何提取模板文件和翻译语言文件。

在这个示例的步骤 4中，我们导出了一个模板文件。--i18n-export选项期望导出路径和文件名。请注意，文件扩展名必须是 CSV、PO 或 TGZ。此选项需要-d选项，它指定要使用的数据库。还需要--modules选项来指示要导出的附加模块。请注意，--stop-after-init选项不是必需的，因为export命令在完成后会自动返回到命令行。

这将导出一个模板文件。Odoo 模块期望在i18n文件夹中找到具有.pot扩展名的导出模板。在处理模块时，导出操作完成后，我们通常希望将导出的 PO 文件移动到模块的i18n目录下，并命名为<模块>.pot。

在步骤 5中，也使用了–language选项。使用它，除了空翻译文件外，还会导出所选语言的翻译术语。这个用例之一是通过使用技术翻译功能通过 Web 客户端用户界面进行一些翻译，然后导出并包含在模块中。

还有更多...

视图和模型定义中的文本字符串会自动提取以进行翻译。对于模型，提取了_description属性、字段名称（string属性）、帮助文本以及选择字段选项，以及模型约束的用户文本（_constraints和_sql_constraints）。

在 Python 或 JavaScript 代码中需要翻译的文本字符串无法自动检测，因此代码应识别这些字符串，并将它们包裹在下划线函数中。

在 Python 的模块文件中，我们应该确保文件以以下方式导入：

from odoo import _

此文件可以在任何需要可翻译文本的地方使用，如下所示：

_('Hello World')

对于使用额外上下文信息的字符串，我们应该使用 Python 字符串插值，如下所示：

_('Hello %s') % 'World'

注意，插值应该放在翻译函数外部。例如，_("Hello %s" % 'World')是错误的。字符串插值也应优先于字符串连接，以便每个界面文本都只是一个翻译字符串。

请小心处理选择字段！如果你向字段定义传递一个显式的值列表，显示的字符串将自动标记为需要翻译。另一方面，如果你传递一个返回值列表的方法，显示字符串必须显式标记为需要翻译。

关于手动翻译工作，任何文本文件编辑器都可以使用，但使用专门支持 PO 文件语法的编辑器可以简化这项工作，减少格式错误的风险。此类编辑器包括以下列表：

POEDIT: poedit.net/

)

Emacs (PO 模式): www.gnu.org/software/gettext/manual/html_node/PO-Mode.html
Lokalize: l10n.kde.org/tools/
Gtranslator: wiki.gnome.org/Apps/Gtranslator

)

使用 gettext 工具使翻译更容易

PO 文件格式是 Unix-like 系统中常用的gettext i18n 和本地化系统的一部分。此系统包括用于简化翻译工作的工具。

这个配方演示了如何使用这些工具来帮助我们翻译我们的附加模块。我们希望在自定义模块上使用它，所以我们在第三章，创建 Odoo 附加模块中创建的my_hostel模块是一个很好的候选者。然而，你也可以自由地用你手头的其他自定义模块替换它，并相应地替换教程中的my_hostel引用。

如何做到这一点...

假设你的 Odoo 安装位于~/odoo-work/odoo，要使用命令行管理翻译，请按照以下步骤操作：

为目标语言创建一个翻译术语汇编——例如，西班牙语。如果我们命名我们的汇编文件为odoo_es.po，我们应该编写以下代码：

$ cd ~/odoo-work/odoo  # Use the path to your Odoo installation
$ find ./ -name es_ES.po | xargs msgcat --use-first | msgattrib
--translated  --no-fuzzy \ -o ./odoo_es.po

从 Odoo 命令行界面导出附加模块的翻译模板文件，并将其放置在模块预期的位置：

$ ./odoo-bin -d mydb --i18n-export=my_module.po --modules=my_module
$ mv my_module.po ./addons/my_module/i18n/my_module.pot

如果目标语言还没有可用的翻译文件，创建 PO 翻译文件，重复使用在汇编中已找到和翻译的术语：
```
$ msgmerge --compendium ./odoo_es.po -o
./addons/my_module/i18n/es_ES.po \
/dev/null ./addons/my_module/i18n/my_module.pot
```

如果存在翻译文件，请添加汇编中可以找到的翻译：

$ mv ./addons/my_module/i18n/es_ES.po /tmp/my_module_es_old.po
$ msgmerge --compendium ./odoo_es.po -o./addons/my_module/i18n/es_ES.po
\ /tmp/my_module_es_old.po ./addons/my_module/i18n/my_module.pot
$ rm /tmp/my_module_es_old.po

要查看 PO 文件中的未翻译术语，请使用以下命令：
```
$ msgattrib --untranslated ./addons/my_module/i18n/es_ES.po
```
使用你喜欢的编辑器来完成翻译。

它是如何工作的...

步骤 1 使用gettext工具箱中的命令为所选语言创建翻译汇编——在我们的例子中是西班牙语。它通过在 Odoo 代码库中查找所有es_ES.po文件，并将它们传递给msgcat命令来实现。我们使用--use-first标志来避免冲突翻译（Odoo 代码库中有一些）。结果传递给msgattrib过滤器。我们使用--translated选项来过滤未翻译条目，并使用--no-fuzzy选项来删除模糊翻译。然后我们将结果保存在odoo_es.po中。

步骤 2 使用--i18n-export选项调用odoo.py。即使配置文件和--modules选项中已指定，您仍需要在命令行上指定一个数据库，并使用逗号分隔的模块列表来导出翻译。

在gettext世界中，模糊翻译是由msgmerge命令（或其他工具）使用源字符串的邻近匹配自动创建的。我们希望在汇编中避免这些。

步骤 3 通过使用在汇编中找到的现有翻译值来创建一个新的翻译文件。使用带有--compendium选项的msgmerge命令来查找汇编文件中的msgid行，匹配在步骤 2中生成的翻译模板文件中的那些。结果保存在es_ES.po文件中。

如果您有一个包含您想要保留的翻译的现有.po文件，您应该将其重命名，并将/dev/null参数替换为该文件。重命名过程是必要的，以避免使用相同的文件作为输入和输出。

将翻译文件导入 Odoo

加载翻译的标准方法是存储 PO 文件在模块的i18n子文件夹中。每当附加模块安装或更新时，翻译文件就会被加载，并添加额外的翻译字符串。

然而，可能存在我们想要直接导入翻译文件的情况。在本教程中，我们将学习如何从网络客户端或命令行加载翻译文件。

准备工作

我们需要激活开发者模式。如果尚未激活，请按照第一章中“激活 Odoo 开发者工具”食谱中的说明进行激活，即安装 Odoo 开发环境。我们还需要一个翻译po文件，我们将在本教程中导入它——例如，myfile.po文件。

如何操作...

要导入翻译术语，请按照以下步骤操作：

在网络客户端用户界面中，从设置顶部菜单，选择翻译 | 导入/导出 | 导入翻译菜单选项。
在导入翻译对话框中，填写语言名称和语言代码，并选择要导入的文件。最后，点击导入按钮：

图 11.13 – 导入翻译文件的对话框

要从 Odoo 命令行界面导入翻译文件，我们必须将其放置在服务器附加路径中，然后执行导入：
```
$ mv myfile.po ./addons/
$ ./odoo.py -d mydb --i18n-import="myfile.po" --lang=fr_BE
```

它是如何工作的...

ir.translation 表，但在 Odoo 的新版本中，该表不再存在。因此，所有针对 arch_db 的视图级别翻译，例如按钮字符串和选择字段值，都将存储在 ir_ui_view 表中，而所有字段级别翻译，例如字段标签，都将存储在 ir_model_fields 表的 field_description 字段下。

例如，我们的宿舍表有一个 room_number 模型。其“房间号”字段翻译将作为 {"en_US": "Room Number", "fr_BE": "Numéro de chambre"} 存储在数据库级别。

网络客户端功能会要求输入语言名称，但在导入过程中并不使用它。它还有一个覆盖选项。如果选中，它将强制导入所有翻译字符串，即使它们已经存在，也会在过程中覆盖它们。

在命令行中，可以使用 --i18n-import 选项进行导入。它必须提供相对于附加路径目录的文件路径；-d 和 --language（或 -l）是必需的。通过添加 --i18n-overwrite 选项到命令中，也可以实现覆盖。请注意，我们在这里没有使用 --stop-after-init 选项。因为它不是必需的，因为导入操作在完成后会停止服务器。

修改网站的定制语言 URL 代码

Odoo 还支持网站的多语言。在网站上，当前语言被识别为语言字符串。在本食谱中，你将学习如何更改 URL 中的语言代码。

准备工作

在遵循此食谱之前，请确保你已经安装了 website 模块并启用了网站的多语言功能。

如何操作...

要修改语言的 URL 代码，请按照以下步骤操作：

从设置 | 翻译 | 语言菜单选项打开语言列表。点击其中一个已安装的语言将打开一个看起来像这样的表单：

图 11.14 – 网站的语言 URL 代码

这里，你会看到URL 代码字段。设置你想要的值。确保你在这里不要添加空格或特殊字符。

配置完成后，你可以在网站上测试结果。打开主页并更改语言；你将看到 URL 中的自定义语言代码。

它是如何工作的...

Odoo 通过 URL 路径识别网站的语种。例如，www.odoo.com/fr_FR 用于法语，www.odoo.com/es_ES 用于西班牙语。在这里，URL 中的 fr_FR 和 es_ES 部分是语言 ISO 代码，Odoo 使用这些代码来检测请求的语言。但有时，你可能希望以更用户友好的方式设置语言。在这种情况下，你可以更新法语对应的 fr。在这种情况下，www.odoo.com/fr_FR 将会被转换为 www.odoo.com/fr。

注意

在生产环境中更改 URL 代码不是问题；Odoo 会自动将包含语言 ISO 代码的 URL 重定向到你的自定义 URL。

第十二章：自动化、工作流程、电子邮件和打印

预期业务应用不仅存储记录，还要管理业务工作流程。一些对象，如潜在客户或项目任务，有很多并行运行的记录。一个对象有太多的记录会使业务情况难以清晰。Odoo 有几种技术可以处理这个问题。在本章中，我们将探讨如何设置具有动态阶段和看板组的业务工作流程。这将帮助用户了解他们的业务是如何运行的。

我们还将探讨如服务器操作和自动化操作等技术，这些技术可以被高级用户或功能顾问使用，以添加更简单的流程自动化，而无需创建自定义插件。最后，我们将创建基于 QWeb 的 PDF 报告并打印出来。

在本章中，我们将涵盖以下菜谱：

管理动态记录阶段
管理看板阶段
向看板卡片添加快速创建表单
创建交互式看板卡片
向看板视图中添加进度条
创建服务器操作
使用 Python 代码服务器操作
在时间条件下使用自动化操作
在事件条件下使用自动化操作
创建基于 QWeb 的 PDF 报告
从看板卡片管理活动
向表单视图添加状态按钮
启用记录的存档选项

技术要求

本章的技术要求是拥有在线 Odoo 平台。

本章将使用的所有代码都可以从本书的 GitHub 仓库下载：github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter12。

管理动态记录阶段

在my_hostel中，我们有一个state字段来指示宿舍房间记录的当前状态。此state字段限制为草稿或可用状态，并且无法向业务流程中添加新状态。为了避免这种情况，我们可以使用many2one字段在用户选择看板工作流程设计时提供灵活性，并且您可以在任何时候添加/删除新状态。

准备工作

对于这个菜谱，我们将使用来自第八章，高级服务器端开发技术的my_hostel模块。此模块管理宿舍和学生。它还记录房间。我们为此书添加了一个初始模块，Chapter12/00_initial_module/my_hostel，到 GitHub 仓库以帮助您开始：github.com/PacktPublishing/Odoo-17-Development-Cookbook-Fifth-Edition/tree/main/Chapter12。

如何操作...

按照以下简单步骤向hostel.room模型添加阶段：

添加一个名为hostel.room.stage的新模型，如下所示：

class HostelRoomStage(models.Model):
    _name = 'hostel.room.stage'
    _order = 'sequence,name'
    name = fields.Char("Name")
    sequence = fields.Integer("Sequence")
security/ir.model.access.csv file, as follows:

从hostel.room模型中替换状态字段，并替换为新的阶段 _id 字段，这是一个 many2one 字段，以及其方法，如下面的示例所示：

@api.model
def _default_room_stage(self):
    Stage = self.env['hostel.room.stage']
state field in the form view with the stage_id field, as shown in the following example:

<field name="stage_id" widget="statusbar"

options="{'clickable': '1', 'fold_field': 'fold'}"/>

在树视图中的状态字段与阶段 _id 字段一起，如下所示：

<tree string="Room">
    <field name="name"/>
    <field name="room_no"/>
    <field name="floor_no"/>
    <field name="stage_id"/>
data/room_stages.xml file. Don’t forget to add this file to the manifest, as shown in the following example:

草稿

可用

预留

True

安装模块后，您将在表单视图中看到阶段，如下面的截图所示：

图 12.1 – 表单视图中的阶段选择器

这里，您会注意到在宿舍记录上勾画出的阶段。这些阶段是可点击的，因此您可以通过点击来更改阶段。折叠阶段将在更多下拉菜单下显示。

工作原理...

由于我们想要动态管理记录阶段，我们需要创建一个新的模型。在步骤 1中，我们创建了一个名为hostel.room.stage的新模型来存储动态阶段。在这个模型中，我们添加了一些字段。其中之一是sequence字段，用于确定阶段的顺序。我们还添加了fold布尔字段，用于折叠阶段并将它们放入下拉列表中。当您的业务流程有很多阶段时，这非常有用，因为它意味着您可以通过设置此字段来在下拉菜单中隐藏不重要的阶段。

fold字段也用于看板视图中显示折叠的看板列。通常，预留项目预计处于未展开阶段，标记为完成或取消的项目应处于折叠阶段。

默认情况下，fold是用于存储阶段折叠值的字段名称。您可以通过添加_fold_name = 'is_fold'类属性来更改此名称。

在步骤 2中，我们为新的模型添加了基本访问权限规则。

在步骤 3中，我们将stage_id many2one字段添加到hostel.room模型中。在创建新的房间记录时，我们希望将默认阶段值设置为草稿。为了完成这个任务，我们添加了_default_room_stage()方法。此方法将检索具有最低序列号的hostel.room.stage模型记录，因此，在创建新记录时，序列号最低的阶段将在表单视图中显示为活动状态。

在第 4 步中，我们将stage_id字段添加到表单视图中。通过添加clickable选项，我们使状态栏可点击。我们还添加了fold字段的选项，这将允许我们在下拉菜单中显示不重要的阶段。

在第 5 步中，我们将stage_id添加到树视图中。

在第 6 步中，我们为各个阶段添加了默认数据。用户安装我们的模块后将会看到这些基本阶段。如果您想了解更多关于 XML 数据语法的知识，请参考第六章中的使用 XML 文件加载数据配方，管理模块数据。

重要提示

在此实现中，用户可以即时定义新的阶段。您需要为hostel.room.stage添加视图和菜单，以便可以从用户界面添加新阶段。如果您不知道如何添加视图和菜单，请参考第九章，后端视图。

如果您不想这样做，Kanban 视图提供了内置功能，可以直接从 Kanban 视图中添加、删除或修改阶段。我们将在下一个配方中查看这一点。

参见

要了解如何添加视图和菜单，请参考第九章，后端视图。

管理 Kanban 阶段

使用Kanban 板是管理工作流程的简单方法。它组织成列，每列对应一个阶段，工作项从左到右移动，直到完成。具有这些阶段的 Kanban 视图提供了灵活性，因为它允许用户选择自己的工作流程。它在一个屏幕上提供了记录的全面概述。

开始使用

在此配方中，我们将使用前一个配方中的my_hostel模块。我们将向hostel.room模型添加 Kanban，并将 Kanban 卡片按阶段分组。

如何操作...

执行以下步骤以启用hostel.room模型的 Kanban 工作流程：

按如下方式为hostel.room添加 Kanban 视图：

<record id="hostel_room_view_kanban" model="ir.ui.view">
    <field name="name">Hostel room Kanban</field>
    <field name="model">hostel.room</field>
    <field name="arch" type="xml">
        <kanban default_group_by="stage_id">
            <field name="stage_id" />
            <templates>
                <t t-name="kanban-box">
                    <div class="oe_kanban_global_click">
                        <div class="oe_kanban_content">
                            <div class="oe_kanban_card">
                                <div>
                                    <b>
                                        <field name="name" />
                                    </b>
                                </div>
                                <div class="text-muted">
                                    <i class="fa fa-building"/>
                                    <field name="hostel_id" />
                                </div>
                            </div>
                        </div>
                    </div>
                </t>
            </templates>
        </kanban>
    </field>
action_hostel_room action, as follows:

...

kanban,tree,form

_group_expand_stages()方法和将 group_expand 属性添加到 stage_id 字段，如下所示：

@api.model
def _group_expand_stages(self, stages, domain, order):
    return stages.search([], order=order)
stage_id = fields.Many2one(
        'hostel.room.stage',
        default=_default_room_stage,
        group_expand='_group_expand_stages'
    )

重新启动服务器并更新模块以应用更改。这将启用 Kanban 板，如下截图所示：

图 12.2 – 按阶段分组的 Kanban 视图

如前一张截图所示，Kanban 视图将按阶段分组显示房间记录。您可以将卡片拖放到另一个阶段列。将卡片移动到另一个列会更改数据库中的阶段值。

它是如何工作的...

在第 1 步中，我们为hostel.room.stage模型添加了 Kanban 视图。请注意，我们使用stage_id作为 Kanban 的默认分组，这样当用户打开 Kanban 时，Kanban 卡片将按阶段分组。要了解更多关于 Kanban 的信息，请参考第九章，后端视图。

在步骤 2中，我们将kanban关键字添加到现有的操作中。

在步骤 3中，我们将group_expand属性添加到stage_id字段。我们还添加了一个新的_group_expand_stages()方法。group_expand改变了字段的分组行为。默认情况下，字段分组显示正在使用的阶段。例如，如果没有房间记录有Reserved阶段，分组将不会返回该阶段，因此看板将不会显示Reserved列。但在这个例子中，我们希望显示所有阶段，无论它们是否正在使用。

_group_expand_stages()函数用于返回所有阶段的记录。因此，看板视图将显示所有阶段，您将能够通过拖放使用工作流。

参见

想了解更多关于看板的信息，请参阅第九章，后端视图。

向看板卡片添加快速创建表单

分组看板视图提供了快速创建功能，允许我们直接从看板视图中生成记录。列上的加号图标将显示一个可编辑的看板卡片，使用它可以创建记录。在这个菜谱中，我们将学习如何设计我们选择的快速创建看板表单。

入门

对于这个菜谱，我们将使用前一个菜谱中的my_hostel模块。我们将为hostel.room模型使用看板的快速创建选项。

如何做...

按照以下步骤为看板添加自定义快速创建表单：

为hostel.room模型创建一个新的最小表单视图，如下所示：

<record id="hostel_room_view_form_minimal" model="ir.ui.view">
    <field name="name">Hostel room Form</field>
    <field name="model">hostel.room</field>
    <field name="arch" type="xml">
        <form>
            <group>
                <field name="name"/>
                <field name="room_no"/>
                <field name="hostel_id" required="1"/>
<field name="floor_no"/>
                <field name="student_per_room"/>
            </group>
        </form>
    </field>
<kanban> tag, as follows:

<kanban default_group_by="stage_id" on_create="quick_create" quick_create_view="my_hostel.hostel_room_view_form_minimal">

重新启动服务器并更新模块以应用更改。然后，点击列中的加号图标。这将启用看板表单，如图下所示：

图 12.3 – 从看板视图直接创建记录

当你在看板视图中点击创建按钮时，你会看到一个带有输入的小卡片，而不是被重定向到表单视图。你可以填写值并点击添加，这将创建一个房间记录。

工作原理...

要创建自定义快速创建选项，我们需要创建一个最小化表单视图。我们在步骤 1中这样做。我们添加了两个必填字段，因为不填写必填字段你无法创建记录。如果你这样做，Odoo 将生成错误并打开默认表单视图在对话框中，以便你可以输入所有必填值。

在步骤 2中，我们将这个新的表单视图添加到看板视图中。使用quick_create_view选项，你可以将自定义表单视图映射到看板视图中。我们还添加了一个额外的选项 – on_create="quick_create"。此选项将在你点击控制面板中的创建按钮时，在第一列显示快速创建表单。如果没有此选项，创建按钮将打开表单视图以编辑模式。

你可以通过在看板标签中添加quick_create="false"来禁用快速创建功能。

创建交互式看板卡片

�看板卡片支持所有 HTML 标签，这意味着你可以按自己的喜好设计它们。Odoo 提供了一些内置方式来使看板卡片更加互动。在本教程中，我们将添加颜色选项、星形小部件和many2many标签到看板卡片中。

开始使用

对于这个教程，我们将使用上一教程中的my_hostel模块。

如何操作...

按照以下步骤创建一个吸引人的看板卡片：

添加一个新模型来管理hostel.room模型的标签，如下所示：

class HostelAmenities(models.Model):
    _name = "hostel.amenities"
    _description = "Hostel Amenities"
    name = fields.Char("Name", help="Provided Hostel Amenity")
    active = fields.Boolean("Active", default=True,
        help="Activate/Deactivate whether the amenity should be given or not")
hostel.amenities model, as follows:

access_hostel_amenities_manager_id,access.hostel.amenities.manager,my_hostel.model_hostel_amenities,my_hostel.group_hostel_manager,1,1,1,1

hostel.room 模型，如下所示：

color = fields.Integer()
    popularity = fields.Selection([('no', 'No Demand'), ('low', 'Low Demand'), ('medium', 'Average Demand'), ('high', 'High Demand'),])
hostel_amenities_ids = fields.Many2many(
    "hostel.amenities",
    "hostel_room_amenities_rel", "room_id", "amenitiy_id",
string="Amenities", domain="[('active', '=', True)]",
    help="Select hostel room amenities")

按照以下方式将字段添加到表单视图中：

<field name="popularity" widget="priority"/>
<field name="hostel_amenities_ids" widget="many2many_tags"
color field to the Kanban view:

在看板视图中添加一个下拉菜单来选择颜色：

<t t-name="kanban-box">
    <div t-attf-class="#{kanban_color(record.color)} oe_kanban_global_click">
        <div class="o_dropdown_kanban dropdown">
            <a class="dropdown-toggle o-no-caret btn" role="button" data-toggle="dropdown">
                <span class="fa fa-ellipsis-v"> </span>
            </a>
            <div class="dropdown-menu" role="menu">
                <t t-if="widget.editable">
                    <a role="menuitem" type="edit" class="dropdown-item">Edit</a>
                </t>
                <t t-if="widget.deletable">
                    <a role="menuitem" type="delete" class="dropdown-item">Delete</a>
                </t>
                <ul class="oe_kanban_colorpicker" data-field="color"/>
            </div>
        </div>
        <div class="oe_kanban_content">
            <div class="oe_kanban_card oe_kanban_global_click">
                <div>
                    <i class="fa fa-bed">  </i>
                    <b>
                        <field name="name" />
                    </b>
                </div>
                <div class="text-muted">
                    <i class="fa fa-building">    </i>
                    <field name="hostel_id" />
                </div>
                <span class="oe_kanban_list_many2many">
                    <field name="hostel_amenities_ids" widget="many2many_tags" options="{'color_field': 'color'}"/>
                </span>
                <div>
                    <field name="popularity" widget="priority"/>
                </div>
            </div>
        </div>
    </div>
</t>
popularity field to the Kanban view:

...