msgid "A :abbr:`CDN (Content Delivery Network)` or *content distribution network*, is a geographically distributed network of servers that provides high speed internet content. The :abbr:`CDN (Content Delivery Network)` provides quick, high-quality content delivery for content-heavy websites."
msgid "On the KeyCDN dashboard, start by navigating to the :menuselection:`Zones` menu item on the left. On the form, give a value to the :guilabel:`Zone Name`, which will appear as part of the :abbr:`CDN (Content Delivery Network)`'s :abbr:`URL (Uniform Resource Locator)`. Then, set the :guilabel:`Zone Status` to :guilabel:`active` to engage the zone. For the :guilabel:`Zone Type` set the value to :guilabel:`Pull`, and then, finally, under the :guilabel:`Pull Settings`, enter the :guilabel:`Origin URL`— this address should be the full Odoo database :abbr:`URL (Uniform Resource Locator)`."
msgid "Use ``https://yourdatabase.odoo.com`` and replace the *yourdatabase* subdomain prefix with the actual name of the database. A custom :abbr:`URL (Uniform Resource Locator)` can be used, as well, in place of the Odoo subdomain that was provided to the database."
msgid "Under the :guilabel:`General Settings` heading below the zone form, click the :guilabel:`Show all settings` button to expand the zone options. This should be the last option on the page. After expanding the :guilabel:`General Settings` ensure that the :guilabel:`CORS` option is :guilabel:`enabled`."
msgid "Next, scroll to the bottom of the zone configuration page and :guilabel:`Save` the changes. KeyCDN will indicate that the new zone will be deployed. This can take about 10 minutes."
msgid "A new :guilabel:`Zone URL` has been generated for your Zone, in this example it is ``pulltest-xxxxx.kxcdn.com``. This value will differ for each database."
msgid "In the Odoo :guilabel:`Website` app, go to the :menuselection:`Settings` and then activate the :guilabel:`Content Delivery Network (CDN)` setting and copy/paste the :guilabel:`Zone URL` value from the earlier step into the :guilabel:`CDN Base URL` field. This field is only visible and configurable when :doc:`Developer Mode <../../applications/general/developer_mode>` is activated."
msgid "Ensure that there are two *forward slashes* (`//`) before the :guilabel:`CDN Base URL` and one forward slash (`/`) after the :guilabel:`CDN Base URL`."
msgid "In the HTML of the Odoo website, the :abbr:`CDN (content delivery network)` integration is evidenced as working properly by checking the :abbr:`URL (Uniform Resource Locators)` of images. The *CDN Base URL* value can be seen by using your web browser's :guilabel:`Inspect` feature on the Odoo website. Look for it's record by searching within the :guilabel:`Network` tab inside of devtools."
msgid "A security restriction in some browsers (such as Mozilla Firefox and Google Chrome) prevents a remotely linked CSS file to fetch relative resources on this same external server."
msgid "If the :abbr:`CORS (Cross-Origin Resource Sharing)` option isn't enabled in the :guilabel:`CDN Zone`, the more obvious resulting problem on a standard Odoo website will be the lack of *Font Awesome* icons because the font file declared in the *Font Awesome* CSS won't be loaded from the remote server."
msgid "When these cross-origin resource issues occur, a security error message similar to the output below will appear in the web browser's developer console:"
msgid "``Font from origin 'http://pulltest-xxxxx.kxcdn.com' has been blocked from loading /shop:1 by Cross-Origin Resource Sharing policy: No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'http://yourdatabase.odoo.com' is therefore not allowed access.``"
msgid "This document describes basic steps to set up Odoo in production or on an internet-facing server. It follows :ref:`installation <setup/install>`, and is not generally necessary for a development systems that is not exposed on the internet."
msgid "Odoo is a multi-tenant system: a single Odoo system may run and serve a number of database instances. It is also highly customizable, with customizations (starting from the modules being loaded) depending on the \"current database\"."
msgid "This is not an issue when working with the backend (web client) as a logged-in company user: the database can be selected when logging in, and customizations loaded afterwards."
msgid "However it is an issue for non-logged users (portal, website) which aren't bound to a database: Odoo needs to know which database should be used to load the website page or perform the operation. If multi-tenancy is not used that is not an issue, there's only one database to use, but if there are multiple databases accessible Odoo needs a rule to know which one it should use."
msgid "That is one of the purposes of :option:`--db-filter <odoo-bin --db-filter>`: it specifies how the database should be selected based on the hostname (domain) that is being requested. The value is a `regular expression`_, possibly including the dynamically injected hostname (``%h``) or the first subdomain (``%d``) through which the system is being accessed."
msgid "For servers hosting multiple databases in production, especially if ``website`` is used, dbfilter **must** be set, otherwise a number of features will not work correctly."
msgid "Show only databases matching the first subdomain after ``www``: for example the database \"mycompany\" will be shown if the incoming request was sent to ``www.mycompany.com`` or ``mycompany.co.uk``, but not for ``www2.mycompany.com`` or ``helpdesk.mycompany.com``."
msgid "Setting a proper :option:`--db-filter <odoo-bin --db-filter>` is an important part of securing your deployment. Once it is correctly working and only matching a single database per hostname, it is strongly recommended to block access to the database manager screens, and to use the ``--no-database-list`` startup parameter to prevent listing your databases, and to block access to the database management screens. See also security_."
msgid "By default, PostgreSQL only allows connection over UNIX sockets and loopback connections (from \"localhost\", the same machine the PostgreSQL server is installed on)."
msgid "UNIX socket is fine if you want Odoo and PostgreSQL to execute on the same machine, and is the default when no host is provided, but if you want Odoo and PostgreSQL to execute on different machines [#different-machines]_ it will need to `listen to network interfaces`_ [#remote-socket]_, either:"
msgid "Only accept loopback connections and `use an SSH tunnel`_ between the machine on which Odoo runs and the one on which PostgreSQL runs, then configure Odoo to connect to its end of the tunnel"
msgid "Accept connections to the machine on which Odoo is installed, possibly over ssl (see `PostgreSQL connection settings`_ for details), then configure Odoo to connect over the network"
msgid "Out of the box, Odoo connects to a local postgres over UNIX socket via port 5432. This can be overridden using :ref:`the database options <reference/cmdline/server/database>` when your Postgres deployment is not local and/or does not use the installation defaults."
msgid "The database management screens are protected by the ``admin_passwd`` setting. This setting can only be set using configuration files, and is simply checked before performing database alterations. It should be set to a randomly generated value to ensure third parties can not use this interface."
msgid "All database operations use the :ref:`database options <reference/cmdline/server/database>`, including the database management screen. For the database management screen to work requires that the PostgreSQL user have ``createdb`` right."
msgid "Users can always drop databases they own. For the database management screen to be completely non-functional, the PostgreSQL user needs to be created with ``no-createdb`` and the database must be owned by a different PostgreSQL user."
msgid "Since Odoo 11.0, you can enforce ssl connection between Odoo and PostgreSQL. in Odoo the db_sslmode control the ssl security of the connection with value chosen out of 'disable', 'allow', 'prefer', 'require', 'verify-ca' or 'verify-full'"
msgid "For production use, it is recommended to use the multiprocessing server as it increases stability, makes somewhat better use of computing resources and can be better monitored and resource-restricted."
msgid "Multiprocessing is enabled by configuring :option:`a non-zero number of worker processes <odoo-bin --workers>`, the number of workers should be based on the number of cores in the machine (possibly with some room for cron workers depending on how much cron work is predicted)"
msgid "In multiprocessing, a dedicated LiveChat worker is automatically started and listening on :option:`the gevent port <odoo-bin --gevent-port>` but the client will not connect to it."
msgid "Instead you must have a proxy redirecting requests whose URL starts with ``/websocket/`` to the gevent port. Other request should be proxied to the :option:`normal HTTP port <odoo-bin --http-port>`"
msgid "To achieve such a thing, you'll need to deploy a reverse proxy in front of Odoo, like nginx or apache. When doing so, you'll need to forward some more http Headers to Odoo, and activate the proxy_mode in Odoo configuration to have Odoo read those headers."
msgid "Whether it's accessed via website/web client or web service, Odoo transmits authentication information in cleartext. This means a secure deployment of Odoo must use HTTPS\\ [#switching]_. SSL termination can be implemented via just about any SSL termination proxy, but requires the following setup:"
msgid "It is also possible to mount Odoo as a standard WSGI_ application. Odoo provides the base for a WSGI launcher script as ``odoo-wsgi.example.py``. That script should be customized (possibly after copying it from the setup directory) to correctly set the configuration directly in :mod:`odoo.tools.config` rather than through the command-line or a configuration file."
msgid "However the WSGI server will only expose the main HTTP endpoint for the web client, website and webservice API. Because Odoo does not control the creation of workers anymore it can not setup cron or livechat workers"
msgid "Which should not be exposed to the network. To ensure cron runners are not network-accessible, it is possible to disable the built-in HTTP server entirely with :option:`odoo-bin --no-http` or setting ``http_enable = False`` in the configuration file"
msgid "The second problematic subsystem for WSGI deployments is the LiveChat: where most HTTP connections are relatively short and quickly free up their worker process for the next request, LiveChat require a long-lived connection for each client in order to implement near-real-time notifications."
msgid "This is in conflict with the process-based worker model, as it will tie up worker processes and prevent new users from accessing the system. However, those long-lived connections do very little and mostly stay parked waiting for notifications."
msgid "Deploy a threaded version of Odoo (instead of a process-based preforking one) and redirect only requests to URLs starting with ``/websocket/`` to that Odoo, this is the simplest and the websocket URL can double up as the cron instance."
msgid "Deploy an evented Odoo via ``odoo-gevent`` and proxy requests starting with ``/websocket/`` to :option:`the gevent port <odoo-bin --gevent-port>`."
msgid "For development convenience, Odoo directly serves all static files and attachments in its modules. This may not be ideal when it comes to performances, and static files should generally be served by a static HTTP server."
msgid "Odoo static files are located in each module's :file:`static/` folder, so static files can be served by intercepting all requests to :samp:`/{MODULE}/static/{FILE}`, and looking up the right module (and file) in the various addons paths."
msgid "Say Odoo has been installed via the **debian packages** for Community and Enterprise and the :option:`--addons-path <odoo-bin --addons-path>` is ``'/usr/lib/python3/dist-packages/odoo/addons'``."
msgid "Say Odoo has been installed via the **source**. The two git repositories for Community and Enterprise have been cloned in :file:`/opt/odoo/community` and :file:`/opt/odoo/enterprise` respectively and the :option:`--addons-path <odoo-bin --addons-path>` is ``'/opt/odoo/community/odoo/addons,/opt/odoo/community/addons,/opt/odoo/enterprise'``."
msgid "The actual NGINX configuration you need is highly dependent on your own installation. The two above snippets only highlight two possible configurations and may not be used as-is."
msgid "Attachments are files stored in the filestore which access is regulated by Odoo. They cannot be directly accessed via a static web server as accessing them requires multiple lookups in the database to determine where the files are stored and whether the current user can access them or not."
msgid "Nevertheless, once the file has been located and the access rights verified by Odoo, it is a good idea to serve the file using the static web server instead of Odoo. For Odoo to delegate serving files to the static web server, the `X-Sendfile <https://tn123.org/mod_xsendfile/>`_ (apache) or `X-Accel <https://www.nginx.com/resources/wiki/start/topics/examples/x-accel/>`_ (nginx) extensions must be enabled and configured on the static web server. Once it is set up, start Odoo with the :option:`--x-sendfile <odoo-bin --x-sendfile>` CLI flag (this unique flag is used for both X-Sendfile and X-Accel)."
msgid "In case you don't know what is the path to your filestore, start Odoo with the :option:`--x-sendfile <odoo-bin --x-sendfile>` option and navigate to the ``/web/filestore`` URL directly via Odoo (don't navigate to the URL via NGINX). This logs a warnings, the message contains the configuration you need."
msgid "For starters, keep in mind that securing an information system is a continuous process, not a one-shot operation. At any moment, you will only be as secure as the weakest link in your environment."
msgid "So please do not take this section as the ultimate list of measures that will prevent all security problems. It's only intended as a summary of the first important things you should be sure to include in your security action plan. The rest will come from best security practices for your operating system and distribution, best practices in terms of users, passwords, and access control management, etc."
msgid "Always set a strong super-admin admin password, and restrict access to the database management pages as soon as the system is set up. See :ref:`db_manager_security`."
msgid "Choose unique logins and strong passwords for all administrator accounts on all databases. Do not use 'admin' as the login. Do not use those logins for day-to-day operations, only for controlling/managing the installation. *Never* use any default passwords like admin/admin, even for test/staging databases."
msgid "Do **not** install demo data on internet-facing servers. Databases with demo data contain default logins and passwords that can be used to get into your systems and cause significant trouble, even on staging/dev systems."
msgid "Use appropriate database filters ( :option:`--db-filter <odoo-bin --db-filter>`) to restrict the visibility of your databases according to the hostname. See :ref:`db_filter`. You may also use :option:`-d <odoo-bin -d>` to provide your own (comma-separated) list of available databases to filter from, instead of letting the system fetch them all from the database backend."
msgid "Once your ``db_name`` and ``db_filter`` are configured and only match a single database per hostname, you should set ``list_db`` configuration option to ``False``, to prevent listing databases entirely, and to block access to the database management screens (this is also exposed as the :option:`--no-database-list <odoo-bin --no-database-list>` command-line option)"
msgid "Make sure the PostgreSQL user (:option:`--db_user <odoo-bin --db_user>`) is *not* a super-user, and that your databases are owned by a different user. For example they could be owned by the ``postgres`` super-user if you are using a dedicated non-privileged ``db_user``. See also :ref:`setup/deploy/odoo`."
msgid "Keep installations updated by regularly installing the latest builds, either via GitHub or by downloading the latest version from https://www.odoo.com/page/download or http://nightly.odoo.com"
msgid "Configure your server in multi-process mode with proper limits matching your typical usage (memory/CPU/timeouts). See also :ref:`builtin_server`."
msgid "Run Odoo behind a web server providing HTTPS termination with a valid SSL certificate, in order to prevent eavesdropping on cleartext communications. SSL certificates are cheap, and many free options exist. Configure the web proxy to limit the size of requests, set appropriate timeouts, and then enable the :option:`proxy mode <odoo-bin --proxy-mode>` option. See also :ref:`https_proxy`."
msgid "If you need to allow remote SSH access to your servers, make sure to set a strong password for **all** accounts, not just `root`. It is strongly recommended to entirely disable password-based authentication, and only allow public key authentication. Also consider restricting access via a VPN, allowing only trusted IPs in the firewall, and/or running a brute-force detection system such as `fail2ban` or equivalent."
msgid "Consider installing appropriate rate-limiting on your proxy or firewall, to prevent brute-force attacks and denial of service attacks. See also :ref:`login_brute_force` for specific measures."
msgid "Many network providers provide automatic mitigation for Distributed Denial of Service attacks (DDOS), but this is often an optional service, so you should consult with them."
msgid "Whenever possible, host your public-facing demo/test/staging instances on different machines than the production ones. And apply the same security precautions as for production."
msgid "If your public-facing Odoo server has access to sensitive internal network resources or services (e.g. via a private VLAN), implement appropriate firewall rules to protect those internal resources. This will ensure that the Odoo server cannot be used accidentally (or as a result of malicious user actions) to access or disrupt those internal resources. Typically this can be done by applying an outbound default DENY rule on the firewall, then only explicitly authorizing access to internal resources that the Odoo server needs to access. `Systemd IP traffic access control <http://0pointer.net/blog/ip-accounting-and-access-lists-with-systemd.html>`_ may also be useful to implement per-process network access control."
msgid "If your public-facing Odoo server is behind a Web Application Firewall, a load-balancer, a transparent DDoS protection service (like CloudFlare) or a similar network-level device, you may wish to avoid direct access to the Odoo system. It is generally difficult to keep the endpoint IP addresses of your Odoo servers secret. For example they can appear in web server logs when querying public systems, or in the headers of emails posted from Odoo. In such a situation you may want to configure your firewall so that the endpoints are not accessible publicly except from the specific IP addresses of your WAF, load-balancer or proxy service. Service providers like CloudFlare usually maintain a public list of their IP address ranges for this purpose."
msgid "Setup daily backups of your databases and filestore data, and copy them to a remote archiving server that is not accessible from the server itself."
msgid "For internet-facing deployments, brute force attacks on user passwords are very common, and this threat should not be neglected for Odoo servers. Odoo emits a log entry whenever a login attempt is performed, and reports the result: success or failure, along with the target login and source IP."
msgid "Here is what it could look like for blocking the IP for 15 minutes when 10 failed login attempts are detected from the same IP within 1 minute::"
msgid "If the management screens must not be accessible at all, you should set ``list_db`` configuration option to ``False``, to block access to all the database selection and management screens."
msgid "It is strongly recommended to disable the Database Manager for any internet-facing system! It is meant as a development/demo tool, to make it easy to quickly create and manage databases. It is not designed for use in production, and may even expose dangerous features to attackers. It is also not designed to handle large databases, and may trigger memory limits."
msgid "On production systems, database management operations should always be performed by the system administrator, including provisioning of new databases and automated backups."
msgid "Be sure to setup an appropriate ``db_name`` parameter (and optionally, ``db_filter`` too) so that the system can determine the target database for each request, otherwise users will be blocked as they won't be allowed to choose the database themselves."
msgid "If the management screens must only be accessible from a selected set of machines, use the proxy server's features to block access to all routes starting with ``/web/database`` except (maybe) ``/web/database/selector`` which displays the database-selection screen."
msgid "If the database-management screen should be left accessible, the ``admin_passwd`` setting must be changed from its ``admin`` default: this password is checked before allowing database-alteration operations."
msgid "technically a tool like socat_ can be used to proxy UNIX sockets across networks, but that is mostly for software which can only be used over UNIX sockets"
msgid "or be accessible only over an internal packet-switched network, but that requires secured switches, protections against `ARP spoofing`_ and precludes usage of WiFi. Even over secure packet-switched networks, deployment over HTTPS is recommended, and possible costs are lowered as \"self-signed\" certificates are easier to deploy on a controlled environment than over the internet."
msgid "Provides greater flexibility: e.g. allow multiple running Odoo versions on the same system. Good for developing modules, can be used as base for production deployment."
msgid "There are two different Editions_ of Odoo: the Community and Enterprise versions. Using the Enterprise version is possible on `Odoo Online`_ and accessing the code is restricted to Enterprise customers and partners. The Community version is freely available to anyone."
msgid "If you already use the Community version and wish to upgrade to Enterprise, please refer to :ref:`setup/enterprise` (except for :ref:`setup/install/source`)."
msgid "To simply get a quick idea of Odoo, demo_ instances are available. They are shared instances which only live for a few hours, and can be used to browse around and try things out with no commitment."
msgid "Trivial to start with, fully managed and migrated by Odoo S.A., `Odoo Online`_ provides private instances and starts out free. It can be used to discover and test Odoo and do non-code customizations (i.e. incompatible with custom modules or the Odoo Apps Store) without having to install it locally."
msgid "Odoo provides packaged installers for Windows, deb-based distributions (Debian, Ubuntu, …) and RPM-based distributions (Fedora, CentOS, RHEL, …) for both the Community and Enterprise versions."
msgid "Official Community packages with all relevant dependency requirements are available on our nightly_ server. Both Community and Enterprise packages can be downloaded from our download_ page (you must to be logged in as a paying customer or partner to download the Enterprise packages)."
msgid "Odoo needs a `PostgreSQL`_ server to run properly. The default configuration for the Odoo 'deb' package is to use the PostgreSQL server on the same host as your Odoo instance. Execute the following command in order to install the PostgreSQL server:"
msgid "Odoo needs a `PostgreSQL`_ server to run properly. Make sure that the `sudo` command is available and well configured and, only then, execute the following command in order to install the PostgreSQL server:"
msgid "`wkhtmltopdf` is not installed through **pip** and must be installed manually in version `0.12.5 <the wkhtmltopdf download page_>`_ for it to support headers and footers. See our `wiki <https://github.com/odoo/odoo/wiki/Wkhtmltopdf>`_ for more details on the various versions."
msgid "Odoo S.A. provides a repository that can be used with Debian and Ubuntu distributions. It can be used to install *Odoo Community Edition* by executing the following commands:"
msgid "Odoo S.A. provides a repository that can be used with the Fedora distributions. It can be used to install *Odoo Community Edition* by executing the following commands:"
msgid "Instead of using the repository as described above, the 'deb' packages for both the *Community* and *Enterprise* editions can be downloaded from the `official download page <download_>`_."
msgid "The `num2words` python package does not exists in Debian Buster nor Ubuntu 18.04. Textual amounts will not be rendered by Odoo and this could cause problems with the `l10n_mx_edi` module."
msgid "Instead of using the repository as described above, the 'rpm' packages for both the *Community* and *Enterprise* editions can be downloaded from the `official download page <download_>`_."
msgid "It also makes starting and stopping Odoo more flexible and explicit than the services set up by the packaged installations, and allows overriding settings using :ref:`command-line parameters <reference/cmdline>` without needing to edit a configuration file."
msgid "The following requires `Git <git_>`_ to be installed on your machine and that you have basic knowledge of Git commands. To clone a Git repository, you must choose between cloning with HTTPS or SSH. If you do not know the difference between the two, the best option is most likely HTTPS. If you are following the :doc:`Getting started </developer/tutorials/getting_started>` developer tutorial, or plan on contributing to Odoo source code, choose SSH."
msgid "**The Enterprise Git repository does not contain the full Odoo source code**. It is only a collection of extra add-ons. The main server code is in the Community version. Running the Enterprise version actually means running the server from the Community version with the addons-path option set to the folder with the Enterprise version. You need to clone both the Community and Enterprise repository to have a working Odoo Enterprise installation. See :ref:`setup/install/editions` to get access to the Enterprise repository."
msgid "**The Enterprise git repository does not contain the full Odoo source code**. It is only a collection of extra add-ons. The main server code is in the Community version. Running the Enterprise version actually means running the server from the Community version with the addons-path option set to the folder with the Enterprise version. You need to clone both the Community and Enterprise repository to have a working Odoo Enterprise installation."
msgid "Odoo requires Python 3.7 or later to run. Visit `Python's download page <https://www.python.org/downloads/windows/>`_ to download and install the latest version of Python 3 on your machine."
msgid "Odoo requires Python 3.7 or later to run. Use your preferred package manager (homebrew_, macports_) to download and install Python 3 on your machine if it is not already done."
msgid "Odoo uses PostgreSQL as database management system. Use your package manager to download and install PostgreSQL (supported version: 12.0 and later)."
msgid "Odoo uses PostgreSQL as database management system. Use `postgres.app <https://postgresapp.com>`_ to download and install PostgreSQL (supported version: 12.0 and later)."
msgid "To make the command line tools bundled with `postgres.app` available, make sure to setup your `$PATH` variable by following the `Postgres.app CLI Tools Instructions <https://postgresapp.com/documentation/cli-tools.html>`_."
msgid "Before installing the dependencies, you must download and install the `Build Tools for Visual Studio <https://visualstudio.microsoft.com/downloads/#build-tools-for-visual-studio-2019>`_. When prompted, select **C++ build tools** in the **Workloads** tab and install them."
msgid "It can be preferable to not mix python modules packages between different instances of Odoo or with your system. You can use virtualenv_ to create isolated Python environments."
msgid "Navigate to the path of your Odoo Community installation (`CommunityPath`) and run **pip** on the requirements file in a terminal **with Administrator privileges**:"
msgid "Edit the System Environment's variable `PATH` to add the folder where `rtlcss.cmd` is located (typically: :file:`C:\\\\Users\\\\<user>\\\\AppData\\\\Roaming\\\\npm\\\\`)."
msgid "Using your **distribution packages** is the preferred way of installing dependencies. Alternatively, you can install the python dependencies with **pip**."
msgid "For Debian-based systems, the packages are listed in the `debian/control <https://github.com/odoo/odoo/blob/saas-16.1/debian/control>`_ file of the Odoo sources."
msgid "The python packages in :file:`requirements.txt` are based on their stable/LTS Debian/Ubuntu corresponding version at the moment of the Odoo release."
msgid "E.g., for Odoo 15.0, the `python3-babel` package version is 2.8.0 in Debian Bullseye and 2.6.0 in Ubuntu Focal. The lowest version is then chosen in the :file:`requirements.txt`."
msgid "Navigate to the path of your Odoo Community installation (:file:`CommunityPath`) and run **pip** on the requirements file to install the requirements for the current user."
msgid "Once all dependencies are set up, Odoo can be launched by running `odoo-bin`, the command-line interface of the server. It is located at the root of the Odoo Community directory."
msgid "To configure the server, you can either specify :ref:`command-line arguments <reference/cmdline/server>` or a :ref:`configuration file <reference/cmdline/config>`."
msgid "For the Enterprise edition, you must add the path to the `enterprise` addons to the `addons-path` argument. Note that it must come before the other paths in `addons-path` for addons to be loaded correctly."
msgid "Where `CommunityPath` is the path of the Odoo Community installation, `dbuser` is the PostgreSQL login, `dbpassword` is the PostgreSQL password, and `mydb` is the name of the PostgreSQL database."
msgid "After the server has started (the INFO log `odoo.modules.loading: Modules loaded.` is printed), open http://localhost:8069 in your web browser and log in with the base administrator account: Use `admin` for the :guilabel:`Email` and, again, `admin` for the :guilabel:`Password`. That's it, you just logged into your own Odoo database!"
msgid "Odoo is compatible with Microsoft's Azure OAuth for Microsoft 365. In order to send and receive secure emails from a custom domain, all that is required is to configure a few settings on the Azure platform and on the back end of the Odoo database. This configuration works with either a personal email address or an address created by a custom domain."
msgid "`Microsoft Learn: Register an application with the Microsoft identity platform <https://learn.microsoft.com/azure/active-directory/develop/quickstart-register-app>`_"
msgid "To get started, go to `Microsoft's Azure Portal <https://portal.azure.com/>`_. Log in with the :guilabel:`Microsoft Outlook Office 365` account if there is one, otherwise log in with the personal :guilabel:`Microsoft account`. A user with administrative access to the Azure Settings will need to connect and perform the following configuration. Next, navigate to the section labeled :guilabel:`Manage Azure Active Directory`."
msgid "Now, click on :guilabel:`Add (+)`, located in the top menu, and then select :guilabel:`App registration`. On the :guilabel:`Register an application` screen, rename the :guilabel:`Name` to `Odoo` or something recognizable. Under the :guilabel:`Supported account types` section select :guilabel:`Accounts in any organizational directory (Any Azure AD directory - Multitenant) and personal Microsoft accounts (e.g. Skype, Xbox)`."
msgid "Under the :guilabel:`Redirect URL` section, select :guilabel:`Web` as the platform, and then input `https://<odoo base url>/microsoft_outlook/confirm` in the :guilabel:`URL` field. The Odoo base URL is the canonical domain at which your Odoo instance can be reached in the URL field."
msgid "The :guilabel:`API permissions` should be set next. Odoo will need specific API permissions to be able to read (IMAP) and send (IMAP) emails in the Microsoft 365 setup. First, click the :guilabel:`API permissions` link, located in the left menu bar. Next, click on the :guilabel:`(+) Add a Permission` button and select :guilabel:`Microsoft Graph` under :guilabel:`Commonly Used Microsoft APIs`. After, select the :guilabel:`Delegated Permissions` option."
msgid "After adding the API permissions, navigate back to the :guilabel:`Overview` of the :guilabel:`Application` in the top of the left sidebar menu."
msgid "Now, add users to this application. Under the :guilabel:`Essentials` overview table, click on the link labeled :guilabel:`Managed Application in Local Directory`, or the last option on the bottom right-hand side of the table."
msgid "In the left sidebar menu, select :guilabel:`Users and Groups`. Next, click on :guilabel:`(+) Add User/Group`. Depending on the account, either a :guilabel:`Group` and a :guilabel:`User` can be added, or only :guilabel:`Users`. Personal accounts will only allow for :guilabel:`Users` to be added."
msgid "Under :guilabel:`Users` or :guilabel:`Groups`, click on :guilabel:`None Selected` and add the users or group of users that will be sending emails from the :guilabel:`Microsoft account` in Odoo. :guilabel:`Add` the users/groups, click :guilabel:`Select`, and then :guilabel:`Assign` them to the application."
msgid "Now that the Microsoft Azure app is set up, credentials need to be created for the Odoo setup. These include the :guilabel:`Client ID` and :guilabel:`Client Secret`. To start, the :guilabel:`Client ID` can be copied from the :guilabel:`Overview` page of the app. The :guilabel:`Client ID` or :guilabel:`Application ID` is located under the :guilabel:`Display Name` in the :guilabel:`Essentials` overview of the app."
msgid "Next, the :guilabel:`Client Secret Value` needs to be retrieved. To get this value, click on :guilabel:`Certificates & Secrets` in the left sidebar menu. Then, a :guilabel:`Client Secret` needs to be produced. In order to do this, click on the :guilabel:`(+) New Client Secret` button."
msgid "A window on the right will populate with a button labeled :guilabel:`Add a client secret`. Under :guilabel:`Description`, type in `Odoo Fetchmail` or something recognizable, and then set the :guilabel:`expiration date`."
msgid "A new :guilabel:`Client Secret` will need to be produced and configured if the first one expires. In this event, there could be an interruption of service, so the expiration date should be noted and set to the furthest possible date."
msgid "Next, click on :guilabel:`Add` when these two values are entered. A :guilabel:`Client Secret Value` and :guilabel:`Secret ID` will be created. It is important to copy the :guilabel:`Value` or :guilabel:`Client Secret Value` into a notepad as it will become encrypted after leaving this page. The :guilabel:`Secret ID` is not needed."
msgid "First, open the Odoo database and navigate to the :guilabel:`Apps` module. Then, remove the :guilabel:`Apps` filter from the search bar and type in `Outlook`. After that, install the module called :guilabel:`Microsoft Outlook`."
msgid "Next, navigate to :menuselection:`Settings --> General Settings`, and under the :guilabel:`Discuss` section, ensure that the checkbox for :guilabel:`Custom Email Servers` is checked. This populates a new option for :guilabel:`Outlook Credentials`."
msgid "Then, copy and paste the :guilabel:`Client ID` (Application ID) and :guilabel:`Client Secret (Client Secret Value)` into the respective fields and :guilabel:`Save` the settings."
msgid "On the :guilabel:`General Settings` page, under the :guilabel:`Custom Email Servers` setting, click the :guilabel:`Outgoing Email Servers` link to configure the Microsoft account."
msgid "Then, create a new email server and check the box for :guilabel:`Outlook`. Next, fill in the :guilabel:`Name` (it can be anything) and the Microsoft Outlook email :guilabel:`Username`."
msgid "A new window from Microsoft opens to complete the :guilabel:`authorization process`. Select the appropriate email address that is being configured in Odoo."
msgid "Then, allow Odoo to access the Microsoft account by clicking on :guilabel:`Yes`. After this, the page will navigate back to the newly configured :guilabel:`Outgoing Mail Server` in Odoo. The configuration automatically loads the :guilabel:`token` in Odoo, and a tag stating :guilabel:`Outlook Token Valid` appears in green."
msgid "Finally, click :guilabel:`Test Connection`. A confirmation message should appear. The Odoo database can now send safe, secure emails through Microsoft Outlook using OAuth authentication."
msgid "Each user should have a separate server set up. The :guilabel:`from-filter` should be set so that only the user's email is sent from that server. In other words, only a user with an email address that matches the set :guilabel:`from-filter` is able to use this server."
msgid "After setting the :guilabel:`from-filter`, set up a fallback email account to allow for the sending of :guilabel:`notifications`. The fallback email must be configured as a :guilabel:`general transactional server`. The :guilabel:`mail.default.from` system parameter must be set to the :guilabel:`username` of the general transactional server account. For more information see :ref:`Use a default email address <email_communication/default>`."
msgid "The :guilabel:`System Parameters` can be accessed by activating :doc:`../../applications/general/developer_mode` in the :menuselection:`Settings --> Technical --> Parameters --> System Parameters` menu."
msgid "The incoming account should be configured in a similar way to the outgoing email account. Navigate to the :guilabel:`Incoming Mail Servers` in the :guilabel:`Technical Menu` and :guilabel:`Create` a new configuration. Check or Select the button next to :guilabel:`Outlook Oauth Authentication` and enter the :guilabel:`Microsoft Outlook username`. Click on :guilabel:`Connect your Outlook account`. Odoo will state: :guilabel:`Outlook Token Valid` Now :guilabel:`Test and Confirm` the account. The account should be ready to receive email to the Odoo database."
msgid "A **domain name** works as an address for your website. It makes the Internet much more accessible as it allows users to type a meaningful web address, such as ``www.odoo.com``, rather than its server's IP address with a series of numbers."
msgid "Odoo Online and Odoo.sh databases, including their websites, use by default a subdomain of ``odoo.com`` for both the URL and the emails (e.g., ``https://example.odoo.com``)."
msgid "Odoo offers a :ref:`free custom domain name <domain-name/odoo-register>` to all Odoo Online databases for one year. Visitors can then access your website with an address such as ``www.example.com`` rather than the default ``example.odoo.com``."
msgid "Having a **good domain name** is as important to your branding as the name of your business or organization as it is the first thing your visitors will notice. We recommend you keep them *simple, short, easy to remember and spell*."
msgid "A **subdomain** is a domain that is a part of another domain. It often refers to the additional part that comes before the main domain name. Traditionally, most websites use the ``www.`` subdomain, but any string of letters can be used as well. You can use subdomains to direct your visitors to other websites than your main website or to specific pages (e.g., ``experience.odoo.com`` points to a specific page.)"
msgid "All domain names are referenced in the **Domain Name System**, or **DNS**, which works as a giant directory for the Internet. There are many DNS servers, so any modification to the DNS can take up to 72 hours to propagate worldwide on all servers."
msgid "Search engines, such as Google and Bing, rely on web crawlers (:dfn:`robots that explore and analyze the web`) to index all websites and their related domain names. These crawlers discover new URLs thanks to links on known web pages. As a result, search engines should index domain names automatically after a while, as long as their URLs are mentioned elsewhere on the Internet."
msgid "Some search engines provide tools for web admins, such as `Google Search Console <https://search.google.com/search-console>`_ and `Bing Webmaster Tools <https://www.bing.com/webmasters>`_, to help you analyze and improve your page ranking. To use these services, you must prove that you are the owner of your domain name. One way to verify the ownership of your domain name is by adding a DNS record. You can do this for :ref:`domain names registered with Odoo <domain-name/odoo-manage>` and for domain names managed by other providers."
msgid "This offer doesn't include any mailbox. However, you can :ref:`configure your MX records <domain-name/odoo-manage>` to use your own email server or solution such as Google Workspace."
msgid "To do so, go to :menuselection:`Website --> Domain Name`. Alternatively, open your `database manager <https://www.odoo.com/my/databases>`_, click on the :guilabel:`settings` button next to your database, then on :guilabel:`Domain names`."
msgid "Your domain name is directly linked to your database, but you still have to :ref:`map your domain name with your website <domain-name/website-map>`."
msgid "Free domain names are also available for free Odoo Online databases (if you installed one app only, for example). In this case, Odoo reviews your request and your website to avoid abuse. This process may take up to three days."
msgid "To manage the DNS records of your domain name registered with Odoo or to visualize the contacts associated with it, open your `database manager <https://www.odoo.com/my/databases>`_, click on the :guilabel:`settings` button next to your database, on :guilabel:`Domain names`, and then on :guilabel:`Contacts` or :guilabel:`DNS`."
msgid "To avoid any issue with the :ref:`SSL certificate validation <domain-name/ssl>`, we highly recommend that you proceed with the following actions in this order:"
msgid "If you want to target a specific branch (production, staging or development), go to :menuselection:`Branches --> select your branch --> Settings --> Custom domains`, and click on :guilabel:`How to set up my domain?`. A message indicates which address your CNAME record should target."
msgid "While Odoo suggests creating a CNAME record for your ``www.`` subdomain (``www.example.com``), you can of course use any domain name of your choice, with any subdomain (e.g., ``anything.example.com``)."
msgid "You own the domain name ``example.com``, and you have an Odoo Online database at the address ``example.odoo.com``. You want to access your Odoo database primarily with the domain ``www.example.com`` but also with the :ref:`naked domain <domain-name/naked-domain>` ``example.com``."
msgid "To do so, you create a CNAME record for the ``www`` subdomain, with ``example.odoo.com`` as the target. The DNS zone manager generates the following rule and adds it to your DNS zone: ``www IN CNAME example.odoo.com.``"
msgid "A **naked domain** is a domain name that doesn't have any subdomain at the beginning of the address (e.g., ``odoo.com`` instead of ``www.odoo.com``)."
msgid "Open your `database manager <https://www.odoo.com/my/databases>`_, click on the :guilabel:`settings` button next to your database, on :guilabel:`Domain names`, and then on :guilabel:`Use my own domain` at the bottom of the right column."
msgid "Type the domain name you want to add to this database, then click on :guilabel:`Verify` to check if the CNAME record is correctly configured. Once done, click on :guilabel:`I confirm, it's done`."
msgid "Go to :menuselection:`Branches --> select your branch --> Settings --> Custom domains`, type the domain name you want to add to this database, then click on :guilabel:`Add domain`."
msgid "Make sure to :ref:`add a CNAME record <domain-name/cname>` to your domain name's DNS **before** mapping your domain name with your Odoo database."
msgid "Failing to do so may impede the validation of the :ref:`SSL certificate <domain-name/ssl>` and would result in a *certificate name mismatch* error. This is often displayed by web browsers as a warning such as *\"Your connection is not private\"*."
msgid "If this is the case and you have added the domain name to your database's settings less than five days ago, wait 24 hours as the validation may still happen. Otherwise, please `submit a support ticket <https://www.odoo.com/help>`_ including screenshots of your CNAME records."
msgid "**SSL encryption** is an encryption-based Internet security protocol. It allows your visitors to navigate your website through a secure connection, which appears as an ``https://`` protocol at the beginning of your web address, rather than a non-secure ``http://`` protocol."
msgid "Odoo generates a separate SSL certificate for each domain :ref:`mapped in the database manager <domain-name/db-map>`, using integration with `Let's Encrypt Certificate Authority and ACME protocol <https://letsencrypt.org/how-it-works/>`_."
msgid "Several attempts to validate your certificate are made during the five days following the moment you add your domain name in your database's settings."
msgid "The **web base URL** of a database, or **root URL** affects your main website address and all the links sent to your customers (e.g., quotations, portal links, etc.)."
msgid "To configure it, access your Odoo database with your custom address, then log in as an administrator of your database (any user in the *Settings* group) from the login screen."
msgid "Connecting to your database with the original Odoo subdomain address (e.g., ``example.odoo.com`` also updates the web base URL of your database. See below to prevent these automatic updates."
msgid "Alternatively, you can do it manually. To do so, activate the :ref:`developer mode <developer-mode>`, then go to :menuselection:`Settings --> Technical --> System Parameters`."
msgid "Find the key called ``web.base.url`` (or create it if it does not exist) and enter the full address of your website as value, such as ``https://www.example.com``."
msgid "Go to :menuselection:`Website --> Configuration --> Settings --> Website Info`. If you have multiple websites, select the one you want to configure."
msgid "Mapping your domain name with your Odoo website prevents Google from indexing both your custom domain name ``www.example.com`` and your original odoo database address ``example.odoo.com``."
msgid "If both addresses are already indexed, it may take some time before Google removes the indexation of the second address. You may also try using the `Google Search Console <https://search.google.com/search-console>`_ to fix this."
msgid "If you have multiple websites and companies on your database, make sure that you select the right :guilabel:`Company` in the website settings, next to the :guilabel:`Domain` settings. Doing so indicates Odoo which URL to use as the :ref:`base URL <domain-name/web-base-url>` according to the company in use."
msgid "You should be able to connect to your Odoo Enterprise instance using your usual mean of identification. You can then link your database with your Odoo Enterprise Subscription by entering the code you received by e-mail in the form input"
msgid "There are many ways to launch your server when using sources, and you probably have your own favourite. You may need to adapt sections to your usual workflow."
msgid "Restart your server with the updated addons path of point 3. You should be able to connect to your instance. You can then link your database with your Odoo Enterprise Subscription by entering the code you received by e-mail in the form input"
msgid "Launch the Odoo Enterprise Installer and follow the steps normally. When choosing the installation path, you can set the folder of the Community installation (this folder still contains the PostgreSQL installation). Uncheck ``Start Odoo`` at the end of the installation"
msgid "No need to manually launch the server, the service is running. You should be able to connect to your Odoo Enterprise instance using your usual mean of identification. You can then link your database with your Odoo Enterprise Subscription by entering the code you received by e-mail in the form input"
msgid "Odoo is compatible with Google's OAuth for Gmail. In order to send secure emails from a custom domain, all that is required is to configure a few settings on Google's *Workspace* platform, as well as on the back end of the Odoo database. This configuration works by using either a personal email address or an address created by a custom domain."
msgid "To get started, go to the `Google API Platform <https://console.cloud.google.com/apis/credentials/consent>`_. Log in with your *Google Workspace* account if you have one, otherwise log in with your personal Gmail account (this should match the email address you want to configure in Odoo)."
msgid "After that, click on :guilabel:`Create Project`, located on the far right of the OAuth consent screen. If a project has already been created in this account, then the :guilabel:`New Project` option will be located on the top left under the :guilabel:`Select a project` drop-down menu."
msgid "On the :guilabel:`New Project` screen, rename the :guilabel:`Project name` to `Odoo` and browse for the :guilabel:`Location`. Set the :guilabel:`Location` as the `Google Workspace` organization. If you are using a personal Gmail account, then leave the :guilabel:`Location` as `No Organization`."
msgid "Click on :guilabel:`Create` to finish this step. On the next screen, :guilabel:`User Type` options, select the :guilabel:`External` option, and then click on :guilabel:`Create` again, which will finally navigate to the :guilabel:`Edit app registration` page."
msgid "On the :guilabel:`Oauth consent screen` step, under the :guilabel:`App information` section, enter `Odoo` in the :guilabel:`App name` field. Select the organization's email address under the :guilabel:`User support` email field."
msgid "After that, under the :guilabel:`Developer contact information` section, enter the organization's email address. Google uses this email address to notify the organization about any changes to your project."
msgid "Next, add the email being configured under the :guilabel:`Test users` step by clicking on :guilabel:`Add Users` and then the :guilabel:`Save and Continue` button. A summary of the :guilabel:`App registration` appears."
msgid "Now that you have set up the project, you need to create credentials, which includes the :guilabel:`Client ID` and :guilabel:`Client Secret`. First, click on :guilabel:`Credentials` in the left sidebar menu."
msgid "Under the :guilabel:`Authorized redirect URIs` label, click the button :guilabel:`ADD URI`, and then input `https://yourdbname.odoo.com/google_gmail/confirm` in the :guilabel:`URIs 1` field. Be sure to replace the *yourdbname* part of the URL with your actual Odoo database name."
msgid "Next, click on :guilabel:`Create` to generate an OAuth :guilabel:`Client ID` and :guilabel:`Client Secret`. Finally, copy each generated value for later use when configuring in Odoo, and then navigate to the Odoo database."
msgid "First, open Odoo and navigate to the :guilabel:`Apps` module. Then, remove the :guilabel:`Apps` filter from the search bar and type in `Google`. Install the module called :guilabel:`Google Gmail`."
msgid "Next, navigate to :menuselection:`Settings --> General Settings`, and under the :guilabel:`Discuss` section, ensure that the checkbox for :guilabel:`Custom Email Servers` is checked. This populates a new option for :guilabel:`Gmail Credentials`. Then, copy and paste the :guilabel:`Client ID` and :guilabel:`Client Secret` into the respective fields and :guilabel:`Save` the settings."
msgid "After that, on the :guilabel:`General Settings` page, under :guilabel:`Custom Email Servers`, click :guilabel:`Outgoing Email Servers` to configure the external Gmail account."
msgid "Then, :guilabel:`Create` a new email server and select the option for :guilabel:`Gmail`. Next, fill in the :guilabel:`Description` (can be anything) and the email :guilabel:`Username` and click on :guilabel:`Connect your Gmail account`."
msgid "A new window from :guilabel:`Google` opens to complete the authorization process. Select the appropriate email address that is being configured in Odoo."
msgid "If the email address is a personal account, an extra step pops up, click :guilabel:`Continue` to allow the verification and connect the Gmail account to Odoo."
msgid "Then, allow Odoo to access the Google account by clicking on :guilabel:`Continue` or :guilabel:`Allow`. After that, the page navigates back to the newly configured outgoing email server in Odoo. The configuration automatically loads the token in Odoo, and a tag stating :guilabel:`Gmail Token Valid` appears in green."
msgid "Finally, save the settings and :guilabel:`Test the Connection`. A confirmation message should appear. The Odoo database can now send safe, secure emails through Google using OAuth authentication."
msgid "To correct this warning, navigate to the `Google API Platform <https://console.cloud.google.com/apis/credentials/consent>`_. If the :guilabel:`Publishing status` is :guilabel:`In Production`, click :guilabel:`Back to Testing` to correct the issue."
msgid "To correct this error, return to the :guilabel:`OAuth consent screen` under :guilabel:`APIs & Services` and add test user(s) to the app. Add the email that you are configuring in Odoo."
msgid "To correct this error, go to the :guilabel:`Apps` module and clear out the search terms. Then, search for `Gmail` or `Google` and upgrade the :guilabel:`Google Gmail` module. Finally, click on the three dots on the upper right of the module and select :guilabel:`Upgrade`."
msgid "When creating the :guilabel:`Credentials` (OAuth Client ID and Client Secret), if :guilabel:`Desktop App` is selected for the :guilabel:`Application Type`, an :guilabel:`Authorization Error` appears."
msgid "To correct this error, delete the credentials already created and create new credentials, selecting :guilabel:`Web Application` for the :guilabel:`Application Type`. Then, under :guilabel:`Authorized redirect URIs`, click :guilabel:`ADD URI` and type: `https://yourdbname.odoo.com/google_gmail/confirm` in the field."
msgid "You may want to move your Odoo database from one hosting solution to another. Depending on the platforms, you have to do it by yourself or contact our support team first."
msgid "`Create a support ticket <https://www.odoo.com/help>`_ and attach the dump (if the file is too large, use any file transfer service and attach the link to your ticket). Also include your subscription number and the URL you want to use for your database (e.g.: my-company.odoo.com)."
msgid "If your database does not run a :ref:`major version <supported_versions>` of Odoo, you cannot host it on-premises yet, you have to upgrade it first to a new major version. (*e.g.: If your database runs Odoo 12.3 which is not a major version, you have to upgrade it first to Odoo 13.0 or 14.0.*)"
msgid "Download a backup of your database by clicking on the \"Gear\" icon next to your database name then :menuselection:`Download` (if the download fails due to your backup file being too large, contact `our support <https://www.odoo.com/help>`_)"
msgid "If your database does not run a :ref:`major version <supported_versions>` of Odoo, you cannot host it on Odoo.sh yet, you have to upgrade it first to a new major version. (*e.g.: If your database runs Odoo 12.3 which is not a major version, you have to upgrade it first to Odoo 13.0 or 14.0.*)"
msgid "The specific **date and time** at which you want the database to be up and running are mainly helpful to organize the switch from the odoo.sh server to the Odoo Online servers."
msgid "Odoo is compatible with Mailjet's :abbr:`API (Application Programming Interface)` for mass mailing. Set up a dedicated mass mailing server through Mailjet by configuring settings in the Mailjet account and the Odoo database. In some circumstances, settings need to be configured on the custom domain's :abbr:`DNS (Domain Name System)` settings as well."
msgid "To get started, sign in to the `Mailjet Account Information <https://app.mailjet.com/account>`_ page. Next, navigate to the :guilabel:`Senders & Domains` section and click on :guilabel:`SMTP and SEND API Settings`."
msgid "Then, copy the :abbr:`SMTP (Simple Mail Transfer Protocol)` configuration settings onto a notepad. They can be found under the :guilabel:`Configuration (SMTP only)` section. The :abbr:`SMTP (Simple Mail Transfer Protocol)` configuration settings include the server address, the security option needed (Use :abbr:`SSL (Secure Sockets Layer)`/:abbr:`TLS (Transport Layer Security)`), and the port number. The settings are needed to configure Mailjet in Odoo, which is covered in the :ref:`last section <maintain/mailjet-api/odoo-setup>`."
msgid "Then, click on the eye icon to reveal the :guilabel:`API key`. Copy this key to a notepad, as this serves as the :guilabel:`Username` in the Odoo configuration. Next, click on the :guilabel:`Generate Secret Key` button to generate the :guilabel:`Secret Key`. Copy this key to a notepad, as this serves as the :guilabel:`Password` in the Odoo configuration."
msgid "The next step is to add a sender address or a domain to the Mailjet account settings so that the email address or domain is approved to send emails using Mailjet's servers. First, navigate to the `Mailjet Account Information <https://app.mailjet.com/account>`_ page. Next, click on the :guilabel:`Add a Sender Domain or Address` link under the :guilabel:`Senders & Domains` section."
msgid "Determine if a sender's email address or the entire domain needs to be added to the Mailjet settings. It may be easier to configure the domain as a whole if :abbr:`DNS (Domain Name System)` access is available. Jump to the :ref:`Add a domain <maintain/mailjet-api/add-domain>` section for steps on adding the domain."
msgid "Either all email addresses of the Odoo database users who are sending emails using Mailjet's servers need to be configured or the domain(s) of the users' email addresses can be configured."
msgid "By default, the email address originally set up in the Mailjet account is added as a trusted sender. To add another email address, click on the button labeled :guilabel:`Add a sender address`. Then, add the email address that is configured to send from the custom domain."
msgid "Replace `yourdomain` with the custom domain for the Odoo database. If there isn't one, then use the :guilabel:`mail.catchall.domain` system parameter."
msgid "After that, fill out the :guilabel:`Email Information` form, making sure to select the appropriate email type: transactional email or mass emails. After completing the form, an activation email is sent to the email address and the trusted sender can be activated."
msgid "It is recommended to set up the :abbr:`SPF (Sender Policy Framework)`/:abbr:`DKIM (DomainKeys Identified Mail)`/:abbr:`DMARC (Domain-based Message Authentication, Reporting, and Conformance)` settings on the domain of the sender."
msgid "If the database is not using a custom domain, then in order to verify the sender's address, a temporary alias (of the three email addresses mentioned above) should be set up in Odoo CRM to create a lead. Then, the database is able to receive the verification email and verify the accounts."
msgid "By adding an entire domain to the Mailjet account, all the sender addresses related to that domain are automatically validated for sending emails using Mailjet servers. First, navigate to the `Mailjet Account Information <https://app.mailjet.com/account>`_ page. Next, click on :guilabel:`Add a Sender Domain or Address` link under the :guilabel:`Senders & Domains` section. Then, click on :guilabel:`Add domain` to add the custom domain."
msgid "After adding the domain, a validation page will populate. Unless the Odoo database is on-premise (in which case, choose :guilabel:`Option 1`), choose :guilabel:`Option 2: Create a DNS Record`. Copy the TXT record information to a notepad and then navigate to the domain's :abbr:`DNS (Domain Name System)` provider to complete validation."
msgid "After getting the TXT record information from the Mailjet account, add a TXT record to the domain's :abbr:`DNS (Domain Name System)`. This process varies depending on the :abbr:`DNS (Domain Name System)` provider. Consult the provider for specific configuration processes. The TXT record information consists of the :guilabel:`Host` and :guilabel:`Value`. Paste these into the corresponding fields in the TXT record."
msgid "After adding the TXT record to the domain's :abbr:`DNS (Domain Name System)`, navigate back to the Mailjet account. Then, navigate to :menuselection:`Account Information --> Add a Sender Domain or Address`, click the gear icon next to :guilabel:`Domain`, and select :guilabel:`Validate`."
msgid "This action can also be done by going to the `Sender domains & addresses <https://app.mailjet.com/ account/sender>`_ page on the Mailjet account information and clicking on :guilabel:`Manage`."
msgid "Next, click :guilabel:`Check Now` to validate the TXT record that was added on the domain. A success screen will appear if the domain is configured correctly."
msgid "After successfully setting up the domain, there is an option to :guilabel:`Authenticate this domain (SPF/DKIM)`. This button populates :abbr:`SPF (Sender Policy Framework)` & :abbr:`DKIM (DomainKeys Identified Mail) records to input into the :abbr:`DNS (Domain Name System)` provider."
msgid "To complete the setup, navigate to the Odoo database and go to the :guilabel:`Settings`. With :ref:`developer-mode` turned on, go to the :menuselection:`Technical Menu --> Email --> Outgoing Mail Servers`. Then, create a new outgoing server configuration by clicking on the :guilabel:`Create` button."
msgid "Next, input the `SMTP server` (in-v3.mailjet.com), `port number` (587 or 465), and `Security (SSL/TLS)` that was copied earlier from the Mailjet account. They can also be found `here <https://app.mailjet.com/account/setup>`_. It is recommended to use :abbr:`SSL (Secure Sockets Layer)`/:abbr:`TLS (Transport Layer Security)` even though Mailjet may not require it."
msgid "For the :guilabel:`Username`, input the :guilabel:`API KEY`. For the :guilabel:`Password`, input the :guilabel:`SECRET KEY` that was copied from the Mailjet account to the notepad earlier. These settings can be found on :menuselection:`Mailjet --> Account Settings --> SMTP and SEND API Settings`."
msgid "Then, if the Mailjet server is used for mass emailing, set the :guilabel:`Priority` value higher than that of any transactional email server(s). Finally, save the settings and :guilabel:`Test the Connection`."
msgid "The :guilabel:`From Filter` needs to be set on the server configuration. It is recommended to set it as a domain and not a full email address. It should match the domain in the two proceeding steps. More information can be referenced :ref:`here <email_communication/from_filter>`."
msgid "The :guilabel:`mail.default.from_filter` system parameter must have the value `yourdomain.com`. Replace `yourdomain` with the custom domain for the Odoo database. If there isn't one, then use the :guilabel:`mail.catchall.domain` system parameter."
msgid "To manage a database, sign in to https://www.odoo.com and access the `database management page <https://www.odoo.com/my/databases>`_ by clicking on the user icon, then on :guilabel:`My Databases`."
msgid "If the database is *not* on the latest **Online version**, the administrator should receive an invitation to :doc:`upgrade <../upgrade>` the database. A :guilabel:`Rolling Release`` button on the database's main screen proposes an upgrade to the latest version (e.g., 14.0 to 16.1)."
msgid "Versions that are not supported anymore become deprecated and need to be updated to avoid security issues. Odoo recommends that the company initiate the upgrade, as this method allows for the company to request a test upgrade of the database to check for any discrepancies."
msgid "By checking :guilabel:`For testing purposes`, all external communication (emails, payments, delivery orders, etc.) are disabled by default on the duplicated database."
msgid "Deleting a database means that all data is permanently lost. The deletion is instant and for all users. It is recommended to create a backup of the database before deleting it."
msgid "It is not possible to delete a database if it is expired or linked to a subscription. If needed, please get in touch with `Odoo Support <https://www.odoo.com/help>`_."
msgid "To invite users, fill out the email address of the new user and click on :guilabel:`Invite`. To add multiple users, click on :guilabel:`Add more users`."
msgid "To register your database, you just need to enter your Subscription Code in the banner in the App Switcher. Make sure you do not add extra spaces before or after your subscription code. If the registration is successful, it will turn green and will provide you with the Expiration Date of your freshly-registered database. You can check this Expiration Date in the About menu (Odoo 9) or in the Settings Dashboard (Odoo 10)."
msgid "Check if your subscription details get the tag \"In Progress\" on your `Odoo Account <https://accounts.odoo.com/my/subscription>`__ or with your Account Manager"
msgid "You can unlink the old database yourself on your `Odoo Contract <https://accounts.odoo.com/my/subscription>`__ with the button \"Unlink database\""
msgid "If it's not the case, you may have multiple databases sharing the same UUID. Please check on your `Odoo Contract <https://accounts.odoo.com/my/subscription>`__, a short message will appear specifying which database is problematic:"
msgid "In this case, you need to change the UUID on your test databases to solve this issue. You will find more information about this in :ref:`this section <duplicate_premise>`."
msgid "For your information, we identify database with UUID. Therefore, each database should have a distinct UUID to ensure that registration and invoicing proceed effortlessly for your and for us."
msgid "The Update notification must be able to reach Odoo's subscription validation servers. In other words, make sure that the Odoo server is able to open outgoing connections towards:"
msgid "Once your database has the correct number of users, the expiration message will disappear automatically after a few days, when the next verification occurs. We understand that it can be a bit frightening to see the countdown, so you can :ref:`force an Update Notification <force_ping>` to make the message disappear right away."
msgid "This **blocking** message appears after a non-blocking message that lasts 30 days. If you fail to take action before the end of the countdown, the database is expired."
msgid "if you wish to pay by Wire Transfer, your subscription will effectively be renewed only when the payment arrives, which can take a few days. Credit card payments are processed immediately."
msgid "You can duplicate your database by accessing the database manager on your server (<odoo-server>/web/database/manager). In this page, you can easily duplicate your database (among other things)."
msgid "When you duplicate a local database, it is **strongly** advised to change the duplicated database's uuid (Unniversally Unique Identifier), since this uuid is how your database identifies itself with our servers. Having two databases with the same uuid could result in invoicing problems or registration problems down the line."
msgid "The database uuid is currently accessible from the menu :menuselection:`Settings --> Technical --> System Parameters`, we advise you to use a `uuid generator <https://www.uuidtools.com>`_ or to use the unix command ``uuidgen`` to generate a new uuid. You can then simply replace it like any other record by clicking on it and using the edit button."
msgid "Odoo releases intermediary versions called **Online versions** on the :doc:`Odoo Online <odoo_online>` hosting every two months. Odoo Online users can then benefit from the latest features of Odoo."
msgid "In order to benefit from the latest improvements, security fixes, bug corrections and performance boosts, you may need to update your Odoo installation from time to time."
msgid "This guide only applies when are using Odoo on your own hosting infrastructure. If you are using one of the Odoo Cloud solutions, updates are automatically performed for you."
msgid "Refers to the process of obtaining the latest revision of the source code for your current Odoo Edition. For example, updating your Odoo Enterprise 13.0 to the latest revision. This does not directly cause any change to the contents of your Odoo database, and can be undone by reinstalling the previous revision of the source code."
msgid "Refers to a complex data processing operation where the structure and contents of your database is permanently altered to make it compatible with a new release of Odoo. This operation is irreversible and typically accomplished via Odoo's `database upgrade service <https://upgrade.odoo.com>`_, when you decide to switch to a newer release of Odoo. Historically, this process has also been known as a \"migration\" because it involves moving data around inside the database, even though the database may end up at the same physical location after the upgrade."
msgid "This page describes the typical steps needed to *update* an Odoo installation to the latest version. If you'd like more information about upgrading a database, please visit the `Odoo Upgrade page <https://upgrade.odoo.com>`_ instead."
msgid "Updating Odoo is accomplished by simply reinstalling the latest version of your Odoo Edition on top of your current installation. This will preserve your data without any alteration, as long as you do not uninstall PostgreSQL (the database engine that comes with Odoo)."
msgid "We always recommend to download a complete new up-to-date Odoo version, rather than manually applying patches, such as the security patches that come with Security Advisories. The patches are mainly provided for installations that are heavily customized, or for technical personnel who prefer to apply minimal changes temporarily while testing a complete update."
msgid "The central download page is https://www.odoo.com/page/download. If you see a \"Buy\" link for the Odoo Enterprise download, make sure you are logged into Odoo.com with the same login that is linked to your Odoo Enterprise subscription."
msgid "The update procedure is quite safe and should not alter you data. However it's always best to take a full database backup before performing any change on your installation, and to store it somewhere safe, on a different computer."
msgid "If you have not disabled the database manager screen (see :ref:`here <security>` why you should), you can use it (link at bottom of your database selection screen) to download a backup of your database(s). If you disabled it, use the same procedure than for your usual backups."
msgid "If you installed Odoo with an installation package downloaded on our website (the recommended method), updating is very simple. All you have to do is download the installation package corresponding to your system (see step #1) and install it on your server. They are updated daily and include the latest security fixes. Usually, you can simply double-click the package to install it on top of the current installation. After installing the package, be sure to restart the Odoo service or reboot your server, and you're all set."
msgid "If you have originally installed Odoo with the \"tarball\" version (source code archive), you have to replace the installation directory with a newer version. First download the latest tarball from Odoo.com. They are updated daily and include the latest security fixes (see step #1) After downloading the package, extract it to a temporary location on your server."
msgid "You will get a folder labelled with the version of the source code, for example \"odoo-13.0+e.20190719\", that contains a folder \"odoo.egg-info\" and the actual source code folder named \"odoo\" (for Odoo 10 and later) or \"openerp\" for older versions. You can ignore the odoo.egg-info folder. Locate the folder where your current installation is deployed, and replace it with the newer \"odoo\" or \"openerp\" folder that was in the archive you just extracted."
msgid "Be sure to match the folder layout, for example the new \"addons\" folder included in the source code should end up exactly at the same path it was before. Next, watch out for any specific configuration files that you may have manually copied or modified in the old folder, and copy them over to the new folder. Finally, restart the Odoo service or reboot the machine, and you are all set."
msgid "If you have originally installed Odoo with a full Github clone of the official repositories, the update procedure requires you to pull the latest source code via git. Change into the directory for each repository (the main Odoo repository, and the Enterprise repository), and run the following commands::"
msgid "The last command may encounter source code conflicts if you had edited the Odoo source code locally. The error message will give you the list of files with conflicts, and you will need to resolve the conflicts manually, by editing them and deciding which part of the code to keep."
msgid "If your project requires additional Python dependencies, or more recent releases, you can define a :file:`requirements.txt` file in the root of your branches listing them. The platform will take care to install these dependencies in your containers. `The pip requirements specifiers <https://pip.pypa.io/en/stable/reference/pip_install/#requirement-specifiers>`_ documentation can help you write a :file:`requirements.txt` file. To have a concrete example, check out the `requirements.txt file of Odoo <https://github.com/odoo/odoo/blob/saas-16.1/requirements.txt>`_."
msgid "The :file:`requirements.txt` files of submodules are taken into account as well. The platform looks for :file:`requirements.txt` files in each folder containing Odoo modules: Not in the module folder itself, but in their parent folder."
msgid "As the containers are Ubuntu based, their directory structure follows the linux Filesystem Hierarchy Standard. `Ubuntu's filesystem tree overview <https://help.ubuntu.com/community/LinuxFilesystemTreeOverview#Main_directories>`_ explains the main directories."
msgid "**Be careful !** `Use transactions <https://www.postgresql.org/docs/current/static/sql-begin.html>`_ (*BEGIN...COMMIT/ROLLBACK*) for every *sql* statements leading to changes (*UPDATE*, *DELETE*, *ALTER*, ...), especially for your production database."
msgid "The transaction mechanism is your safety net in case of mistake. You simply have to rollback your changes to revert your database to its previous state."
msgid "However, do not forget to either commit or rollback your transaction after having done it. Open transactions may lock records in your tables and your running database may wait for them to be released. It can cause a server to hang indefinitely."
msgid "You can start an Odoo server instance from a container shell. You won't be able to access it from the outside world with a browser, but you can for instance:"
msgid "**Be careful**, especially with your production database. Operations that you perform running this Odoo server instance are not isolated: Changes will be effective in the database. Always, make your tests in your staging databases."
msgid "Debugging an Odoo.sh build is not really different than another Python app. This article only explains the specificities and limitations of the Odoo.sh platform, and assumes that you already know how to use a debugger."
msgid "You can use ``pdb``, ``pudb`` or ``ipdb`` to debug your code on Odoo.sh. As the server is run outside a shell, you cannot launch the debugger directly from your Odoo instance backend as the debugger needs a shell to operate."
msgid "This is due to the fact that there might be multiple customers on the same server, and we must guarantee a fair share of the server for every customer. Scheduled actions are therefore implemented slightly differently than on a regular Odoo server, and are run on a *best effort* policy."
msgid "**Odoo.sh always limits the execution time of scheduled actions (*aka* crons).** Therefore, you must keep this fact in mind when developing your own crons."
msgid "Your scheduled actions should commit their work after processing each batch; this way, if they get interrupted by the time-limit, there is no need to start over."
msgid "Your scheduled actions should be `idempotent <https://stackoverflow.com/a/1077421/3332416>`_: they must not cause side-effects if they are started more often than expected."
msgid "A `Git submodule <https://git-scm.com/book/en/v2/Git-Tools-Submodules>`_ allows you to integrate other Git projects into your code, without the need to copy-paste all their code."
msgid "Indeed, your custom modules can depend on modules from other repositories. Regarding Odoo, this feature allows you to add modules from other Git repositories into the branches of your repository. Adding these dependencies in your branch through submodules makes the deployment of your code and servers easier, as you can clone the repositories added as submodules at the same time you clone your own repository."
msgid "Besides, you can choose the branch of the repository added as submodule and you have the control of the revision you want. It's up to you to decide whether you want to pin the submodule to a specific revision and when you want to update to a newer revision."
msgid "In Odoo.sh, the submodules give you the possibility to use and depend on modules available in other repositories. The platform will detect that you added modules through submodules in your branches and add them to your addons path automatically so you can install them in your databases."
msgid "If you add private repositories as submodules in your branches, you need to configure a deploy key in your Odoo.sh project settings and in your repository settings. Otherwise Odoo.sh won't be allowed to download them. The procedure is detailed in the chapter :ref:`Settings > Submodules <odoosh-gettingstarted-settings-submodules>`."
msgid "For now it is not possible to add **private** repositories with this method. You can nevertheless do so :ref:`with Git <odoosh-advanced-submodules-withgit>`."
msgid "You can read the `git-scm.com documentation <https://git-scm.com/book/en/v2/Git-Tools-Submodules>`_ for more details about the Git submodules. For instance, if you would like to update your submodules to have their latest revision, you can follow the chapter `Pulling in Upstream changes <https://git-scm.com/book/en/v2/Git-Tools-Submodules#_pulling_in_upstream_changes_from_the_submodule_remote>`_."
msgid "If you're adding a repository that contains a lot of modules, you may want to ignore some of them in case there are any that are installed automatically. To do so, you can prefix your submodule folder with a :code:`.`. The platform will ignore this folder and you can hand pick your modules by creating symlinks to them from another folder."
msgid "If your changes require the update of a module, such as a change in a form view, and you want it to be performed automatically, increase the version number of the module in its manifest (*__manifest__.py*). The platform will then take care to perform the update during which the instance will be held temporarily unavailable for maintenance reason."
msgid "This method is equivalent to perform an upgrade of the module through the Apps menu, or through the :code:`-u` switch of :doc:`the command line </developer/reference/cli>`."
msgid "In the case the changes in the commit prevent the server to restart, or if the modules update fails, the server is automatically reverted to the previous successful code revision and the database is roll-backed as it was before the update. You still have access to the log of the failed update, so you can troubleshoot it."
msgid "The demo data is not loaded, as it is not meant to be used in a production database. The unit tests are not performed, as it would increase the unavailability time of the production database during the updates."
msgid "Partners using trial projects should be aware their production branch, along with all the staging branches, will automatically be set back to the development stage after 30 days."
msgid "Staging branches are meant to test your new features using the production data without compromising the actual production database with test records. They will create databases that are neutralized duplicates of the production database."
msgid "Disabling scheduled actions. If you want to test them, you can trigger their action manually or re-enable them. Be aware that the platform will trigger them less often if no one is using the database in order to save up resources."
msgid "Disabling outgoing emails by intercepting them with a mailcatcher. An :ref:`interface to view <odoosh-gettingstarted-branches-tabs-mails>` the emails sent by your database is provided. That way, you do not have to worry about sending test emails to your contacts."
msgid "The latest database will be kept alive indefinitely, older ones from the same branch may get garbage collected to make room for new ones. It will be valid for 3 months, after which you will be expected to rebuild the branch. If you make configuration or view changes in these databases, make sure to document them or write them directly in the modules of the branch, using XML data files overriding the default configuration or views."
msgid "The unit tests are not performed as, in Odoo, they currently rely on the demo data, which is not loaded in the production database. In the future, if Odoo supports to run the unit tests without the demo data, Odoo.sh will then consider running the tests on staging databases."
msgid "Development branches create new databases using the demo data to run the unit tests. The installed modules are the ones included in your branches. You can change this list of modules to install in your :ref:`project Settings <odoosh-gettingstarted-settings-modules-installation>`."
msgid "When you push a new commit in one of these branches, a new server is started, with a database created from scratch and the new revision of the branch. The demo data is loaded, and the unit tests are performed by default. This verifies your changes do not break any of the features tested by them. If you wish, you can disable the tests or allow specific tests to be run with custom tags in the :ref:`branch's settings <odoosh-gettingstarted-branches-tabs-settings>`."
msgid "Similar to staging branches, the emails are not sent but are intercepted by a mailcatcher and scheduled actions are not triggered as often is the database is not in use."
msgid "The databases created for development branches are meant to live around three days. After that, they can be automatically garbage collected to make room for new databases without prior notice."
msgid "When your latest changes are ready for production, you can drag and drop your staging branch onto your production branch to merge and deploy in production your newest features."
msgid "If you are bold enough, you can merge your development branches into your production branch as well. It just means you skip the validation of your changes with the production data through a staging branch."
msgid "Of course, you can also use :code:`git merge` directly on your workstation to merge your branches. Odoo.sh will be notified when new revisions have been pushed in your branches."
msgid "Merging a staging branch in the production branch only merges the source code: Any configuration changes you made in the staging databases are not passed to the production database."
msgid "write the configuration changes in XML data files overriding the default configuration or views in your branches, and then increase the version of your module in its manifest (*__manifest__.py*) to trigger the update of the module when you merge your staging branch in your production branch. This is the best practice for a better scalability of your developments as you will use the Git versioning features for all your configuration changes, and therefore have a traceability for your changes."
msgid "For each event, a status is displayed in the top right-hand corner. It can provide information about the ongoing operation on the database (installation, update, backup import, ...), or its result (tests feedback, successful backup import, ...). When an operation is successful, you can access the database thanks to the *connect* button."
msgid "This tab contains the mail catcher. It displays an overview of the emails sent by your database. The mail catcher is available for your development and staging branches as the emails of your production database are really sent instead of being intercepted."
msgid "A shell access to your container. You can perform basic linux commands (:code:`ls`, :code:`top`) and open a shell on your database by typing :code:`psql`."
msgid "An online integrated development environment (IDE) to edit the source code. You can also open terminals, Python consoles and even Odoo Shell consoles."
msgid "You can zoom, change the time range or select a specific metric on each graph. On the graphs, annotations help you relate to changes on the build (database import, git push, etc...)."
msgid "If new lines are added in the logs, they will be displayed automatically. If you scroll to the bottom, the browser will scroll automatically each time a new line is added."
msgid "You can pause the logs fetching by clicking on the according button in the upper right corner of the view. The fetching is automatically stopped after 5 minutes. You can restart it using the play button."
msgid "Odoo.sh makes daily backups of the production database. It keeps 7 daily, 4 weekly and 3 monthly backups. Each backup includes the database dump, the filestore (attachments, binary fields), logs and sessions."
msgid "Staging and development databases are not backed up. You nevertheless have the possibility to restore a backup of the production database in your staging branches, for testing purposes, or to manually recover data that has been deleted by accident from the production database."
msgid "The list contains the backups kept on the server your production database is hosted on. This server only keeps one month of backups: 7 daily and 4 weekly backups."
msgid "Dedicated backup servers keep the same backups, as well as 3 additional monthly backups. To restore or download one of these monthly backups, please `contact us <https://www.odoo.com/help>`_."
msgid "If you merge a commit updating the version of one or several modules (in :file:`__manifest__.py`), or their linked python dependencies (in :file:`requirements.txt`), then Odoo.sh performs a backup automatically (flagged with type Update in the list), as either the container will be changed by the installation of new pip packages, either the database itself will be changed with the module update triggered afterwards. In these two cases, we are doing a backup as it may potentially break things."
msgid "If you merge a commit that only changes some code without the above-mentioned modifications, then no backup is done by Odoo.sh, as neither the container nor the database is modified so the platform considers this safe enough. Of course, as an extra precaution, you can make a backup manually before making big changes in your production sources in case something goes wrong (those manual backups are available for about one week). To avoid abuse, we limit manual backups to 5 per day."
msgid "For development and staging branches, you can change the branch's behavior upon receiving a new commit. By default, a development branch will create a new build and a staging branch will update the previous build (see the :ref:`Production Stage <stage_production>`). This is especially useful should the feature you're working on require a particular setup or configuration, to avoid having to manually set it up again on every commit. If you choose new build for a staging branch, it will make a fresh copy from the production build every time a commit is pushed. A branch that is put back from staging to development will automatically be set to 'Do nothing'."
msgid "*Install only my modules* will install the modules of the branch only. This is the default option. The :ref:`submodules <odoosh-advanced-submodules>` are excluded."
msgid "*Full installation (all modules)* will install the modules of the branch, the modules included in the submodules and all standard modules of Odoo. When running the full installation, the test suite is disabled."
msgid "*Install a list of modules* will install the modules specified in the input just below this option. The names are the technical name of the modules, and they must be comma-separated."
msgid "If the tests are enabled, the standard Odoo modules suite can take up to 1 hour. This setting applies to development builds only. Staging builds duplicate the production build and the production build only installs base."
msgid "For development branches, you can choose to enable or disable the test suite. It's enabled by default. When the test suite is enabled, you can restrict them by specifying test tags :ref:`test tags <developer/reference/testing/selection>`."
msgid "For development branches only, you can change the version of Odoo, should you want to test upgraded code or develop features while your production database is in the process of being upgraded to a newer version."
msgid "You can choose to benefit from the latest bug, security and performance fixes automatically. The sources of your Odoo server will be updated weekly. This is the 'Latest' option."
msgid "You can choose to pin the Odoo sources to a specific revision by selecting them from a list of dates. Revisions will expire after 3 months. You will be notified by mail when the expiration date approaches and if you don't take action afterwards, you will automatically be set to the latest revision."
msgid "Here you can configure additional domains for the selected branch. It's possible to add other *<name>.odoo.com* domains or your own custom domains. For the latter you have to:"
msgid "in your domain name manager (e.g. *godaddy.com*, *gandi.net*, *ovh.com*), configure *www.mycompany.com* with a ``CNAME`` record with as value *mycompany.odoo.com*."
msgid "the IP address of your database can change, following an upgrade, a hardware failure or your wish to host your database in another country or continent."
msgid "In addition, if you would like both *mycompany.com* and *www.mycompany.com* to work with your database, having the first redirecting to the second is amongst the `SEO best practices <https://support.google.com/webmasters/answer/7451184?hl=en>`_ (See *Provide one version of a URL to reach a document*) in order to have one dominant URL. You can therefore just configure *mycompany.com* to redirect to *www.mycompany.com*. Most domain managers have the feature to configure this redirection. This is commonly called a web redirection."
msgid "If the redirection is correctly set up, the platform will automatically generate an SSL certificate with `Let's Encrypt <https://letsencrypt.org/about/>`_ within the hour and your domain will be accessible through HTTPS."
msgid "While it is currently not possible to configure your own SSL certificates on the Odoo.sh platform we are considering the feature if there is enough demand."
msgid "In case the domain of your users email addresses use SPF (Sender Policy Framework) or DKIM (DomainKeys Identified Mail), don't forget to authorize Odoo as a sending host in your domain name settings to increase the deliverability of your outgoing emails. The configuration steps are explained in the documentation about :ref:`SPF <email_communication/spf_compliant>` and :ref:`DKIM <email_communication/dkim_compliant>`."
msgid "Forgetting to configure your SPF or DKIM to authorize Odoo as a sending host can lead to the delivery of your emails as spam in your contacts inbox."
msgid "Each command can be copied in the clipboard to be used in a terminal, and some of them can be used directly from Odoo.sh by clicking the *run* button in such case a popup will prompt the user in order to define eventual placeholders such as ``<URL>``, ``<PATH>``, ..."
msgid "`Generate a new SSH key <https://help.github.com/en/github/authenticating-to-github/generating-a-new-ssh-key-and-adding-it-to-the-ssh-agent#generating-a-new-ssh-key>`_"
msgid "`Copy the SSH key to your clipboard <https://help.github.com/en/github/authenticating-to-github/adding-a-new-ssh-key-to-your-github-account>`_ (only apply the step 1)"
msgid "Provided you have the :ref:`correct access rights <odoosh-gettingstarted-settings-collaborators>` on the project, you'll be granted ssh access to the build."
msgid "In Odoo.sh, a build is considered as a database loaded by an Odoo server (`odoo/odoo <https://github.com/odoo/odoo>`_ & `odoo/enterprise <https://github.com/odoo/enterprise>`_) running on a specific revision of your project repository in a containerized environment. Its purpose is to test the well-behavior of the server, the database and the features with this revision."
msgid "Most of the time, builds are created following pushes on your Github repository branches. They can be created as well when you do other operations, such as importing a database on Odoo.sh or asking a rebuild for a branch in your project."
msgid "If warnings come up during the creation, but there are no errors, the build is considered almost successful. It is highlighted in yellow to notify the developer warnings were raised."
msgid "Builds do not always create a database from scratch. For instance, when pushing a change on the production branch, the build created just starts the server with your new revision and tries to load the current production database on it. If no errors come up, the build is considered successful, and otherwise failed."
msgid "The first build of a production branch creates a database from scratch. If this build is successful, this database is considered as the production database of your project."
msgid "From then, pushes on the production branch will create new builds that attempt to load the database using a server running with the new revision."
msgid "If the build is successful, or has warnings but no errors, the production database will now run with this build, along with the revision associated to this build."
msgid "If the build fails to load or update the database, then the previous successful build is re-used to load the database, and therefore the database will run using a server running with the previous successful revision."
msgid "The build used to run the production database is always the first of the builds list. If a build fails, it is put after the build currently running the production database."
msgid "Each time you push a new revision on a staging branch, the build created uses a new copy of the production database. The databases are not re-used between builds of the same branch. This ensures:"
msgid "you can play around as much as you want in the same staging database, and you can then ask for a rebuild when you want to restart with a new copy of the production."
msgid "Nevertheless, this means that if you make configuration changes in staging databases and do not apply them in the production, they will not be passed on the next build of the same staging branch."
msgid "A build will be considered failed and highlighted in red if tests fail during the installation, as they are meant to raise errors if something wrong occurs."
msgid "According to the list of modules to install and test, a development build can take up to 1 hour to be ready. This is due to the large number of tests set in the default Odoo modules suite."
msgid "The production branch will always appear first, and then the other branches are ordered by last build created. You can filter out the branches."
msgid "For each branch, you can access the last build's database using the *Connect* link and jump to the branch code using the *Github* link. For other branches than the production, you can create a new build which will use the latest revision of the branch using the link *rebuild*. This last link is not available when there is already a build in progress for the branch."
msgid "For each build, you can access the revision changes using the button with the Github icon. You can access the build's database as the administrator using the *Connect* button. Also, you can access the database with another user using the *Connect as* button, in the dropdown menu of the *Connect* button."
msgid "In the dropdown menu of the build, you can access the same features than in :ref:`the branches view <odoosh-gettingstarted-branches-tabs>`: *Logs*, *Web Shell*, *Editor*, *Outgoing e-mails*. You also have the possibility to *Download a dump* of the build's database."
msgid "to commit changes to make your deployment easier, merging branches or adding new `submodules <https://git-scm.com/book/en/v2/Git-Tools-Submodules>`_ for example."
msgid "Choose the Odoo version you want to use. If you plan to import an existing database or an existing set of applications, you might need to choose the according version. If you start from scratch, use the latest version."
msgid "Partners can use their partnership codes to start a trial. Should their clients start a project, they ought to get an Enterprise subscription including Odoo.sh and use its subscription code. The partner will get 50% of the amount back as commission. Contact your sales representative or account manager in order to get it."
msgid "You can import your database in your Odoo.sh project as long as it is in a :doc:`supported version </administration/maintain/supported_versions>` of Odoo."
msgid "If you use community or custom modules, add them in a branch in your Github repository. Databases hosted on the Odoo.com online platform do not have any custom modules. Users of these databases can therefore skip this step."
msgid "You can structure your modules as you wish, Odoo.sh will automatically detect the folders containing Odoo addons. For instance, you can put all your modules folder in the root directory of your repository, or group the modules in folders by categories that you define (accounting, project, ...)."
msgid "For community modules available in public Git repositories, you can also consider to add them using :ref:`Submodules <odoosh-advanced-submodules>`."
msgid "Then, either :ref:`make this branch the production branch <odoosh-gettingstarted-branches-stages>`, or :ref:`merge it into your production branch <odoosh-gettingstarted-branches-mergingbranches>`."
msgid "If you cannot access the database manager, it may have been disabled by your system administrator. See the :ref:`database manager security documentation <db_manager_security>`."
msgid "There is a default mail server provided with Odoo.sh. To use it, there must be no enabled outgoing mail server configured in your database in :menuselection:`Settings --> Technical --> Outgoing Mail Servers` (:ref:`Developer mode <developer-mode>` must be activated)."
msgid "This is to prevent your newly imported database to perform actions that could impact your running production, such as sending the mails remaining in the queue, processing mass mailings, or third-party services synchronization (Calendars, files hosting, ...)."
msgid "If you plan to make the imported database your production, enable the scheduled actions you need. You can check what is enabled in the database of origin and enable the same actions in the imported database. Scheduled actions are located under :menuselection:`Settings --> Technical --> Automation --> Scheduled Actions`."
msgid "The imported database is considered a duplicate by default and the enterprise subscription is therefore removed, as you can only have one database linked per subscription."
msgid "If you plan to make it your production, unlink your former database from the subscription, and register the newly imported database. Read the :doc:`database registration documentation <../../maintain/on_premise>` for instructions."
msgid "While not necessary, scaffolding avoids the tedium of setting the basic Odoo module structure. You can scaffold a new module using the executable *odoo-bin*."
msgid "If you do not want to bother installing Odoo on your computer, you can also :download:`download this module structure template <first_module/my_module.zip>` in which you replace every occurrences of *my_module* to the name of your choice."
msgid "Do not use special characters other than the underscore ( _ ) for your module name, not even an hyphen ( - ). This name is used for the Python classes of your module, and having classes name with special characters other than the underscore is not valid in Python."
msgid "*__manifest__.py*, the manifest of your module, including for instance its title, description and data files to load. You just need to uncomment the access control list data file:"
msgid "If you want to create your module structure manually, you can follow the :doc:`/developer/tutorials/getting_started` tutorial to understand the structure of a module and the content of each file."
msgid "The above command is explained in the section :ref:`Commit & Push your changes <odoosh-gettingstarted-online-editor-push>` of the :ref:`Online Editor <odoosh-gettingstarted-online-editor>` chapter. It includes the explanation regarding the fact you will be prompted to type your username and password, and what to do if you use the two-factor authentication."
msgid "You need to specify *-u origin feature-1* for the first push only. From that point, to push your future changes from your computer, you can simply use"
msgid "You can see here the changes you just pushed, including the comment you set. Once the database ready, you can access it by clicking the *Connect* button."
msgid "If your Odoo.sh project is configured to install your module automatically, you will directly see it amongst the database apps. Otherwise, it will be available in the apps to install."
msgid "Once you tested your module in a development build with the demo data and believe it is ready, you can test it with the production data using a staging branch."
msgid "This will create a new staging build, which will duplicate the production database and make it run using a server updated with your latest changes of your branch."
msgid "Your module will not be installed automatically, you have to install it from the apps menu. Indeed, the purpose of the staging build is to test the behavior of your changes as it would be on your production, and on your production you would not like your module to be installed automatically, but on demand."
msgid "Once you tested your module in a staging branch with your production data, and believe it is ready for production, you can merge your branch in the production branch."
msgid "This will merge the latest changes of your staging branch in the production branch, and update your production server with these latest changes."
msgid "Your module will not be installed automatically, you have to install it manually as explained in the :ref:`above section about installing your module in staging databases <odoosh-gettingstarted-firstmodule-productiondata-install>`."
msgid "If you would like the update to be performed automatically by the Odoo.sh platform when you push your changes, increase your module version in its manifest."
msgid "Once you tested your changes, you can merge your changes in the production branch, for instance by drag-and-dropping the branch on the production branch in the Odoo.sh interface. As you increased the module version in the manifest, the platform will update the module automatically and your new field will be directly available. Otherwise you can manually update the module within the apps list."
msgid "If you would like to use an external Python library which is not installed by default, you can define a *requirements.txt* file listing the external libraries your modules depends on."
msgid "It is not possible to install or upgrade system packages on an Odoo.sh database (e.g., apt packages). However, under specific conditions, packages can be considered for installation. This also applies to **Python modules** requiring system packages for their compilation, and **third-party Odoo modules**."
msgid "The online editor allows you to edit the source code of your builds from a web browser. It also gives you the possibility to open terminals, Python consoles, Odoo Shell consoles and `Notebooks <https://jupyterlab.readthedocs.io/en/stable/user/notebook.html>`_."
msgid "You can access the editor of a build through :ref:`the branches tabs <odoosh-gettingstarted-branches-tabs>`, :ref:`the builds dropdown menu <odoosh-gettingstarted-builds-dropdown-menu>` or by adding */odoo-sh/editor* to your build domain name (e.g. *https://odoo-addons-master-1.dev.odoo.com/odoo-sh/editor*)."
msgid "You can then begin to make your changes. You can save your changes with the menu :menuselection:`File --> Save .. File` or by hitting the :kbd:`Ctrl+S` shortcut."
msgid "If you save a Python file which is under your Odoo server addons path, Odoo will detect it and reload automatically so your changes are reflected immediately, without having to restart the server manually."
msgid "However, if the change is a data stored in database, such as the label of a field, or a view, you have to update the according module to apply the change. You can update the module of the currently opened file by using the menu :menuselection:`Odoo --> Update current module`. Note that the file considered as currently opened is the file focused in the text editor, not the file highlighted in the file browser."
msgid "<branch> must be replaced by the name of the branch to which you want to push the changes, most-likely the current branch if you work in a development build."
msgid "The SSH Github remote is not used because your SSH private key is not hosted in your build containers (for obvious security concerns) nor forwarded through an SSH Agent (as you access this editor through a web browser) and you therefore cannot authenticate yourself to Github using SSH. You have to use the HTTPS remote of your Github repository to push your changes, which is added automatically named as *https* in your Git remotes. You will be prompted to enter your Github username and password. If you activated the two-factor authentication on Github, you can create a `personal access token <https://help.github.com/articles/creating-a-personal-access-token-for-the-command-line/>`_ and use it as password. Granting the ``repo`` permission suffices."
msgid "The Git source folder *~/src/user* is not checked out on a branch but rather on a detached revision: This is because builds work on specific revisions rather than branches. In other words, this means you can have multiple builds on the same branch, but on different revisions."
msgid "Once your changes are pushed, according to your :ref:`branch push behavior <odoosh-gettingstarted-branches-tabs-settings>`, a new build may be created. You can continue to work in the editor you pushed from, as it will have the same revision as the new build that was created, but always make sure to be in an editor of a build using the latest revision of your branch."
msgid "You can open Python consoles, which are `IPython interactive shells <https://ipython.readthedocs.io/en/stable/interactive/tutorial.html>`_. One of the most interesting addition to use a Python console rather than a IPython shell within a terminal is the `rich display <https://ipython.readthedocs.io/en/stable/config/integrating.html#rich-display>`_ capabilities. Thanks to this, you will be able to display objects in HTML."
msgid "You can also open an Odoo Shell console to play around with the Odoo registry and model methods of your database. You can also directly read or write on your records."
msgid "In an Odoo Console, transactions are automatically committed. This means, for instance, that changes in records are applied effectively in the database. If you change the name of a user, the name of the user is changed in your database as well. You therefore should use Odoo consoles carefully on production databases."
msgid "The class :code:`Pretty` gives you the possibility to easily display lists and dicts in a pretty way, using the `rich display <https://ipython.readthedocs.io/en/stable/config/integrating.html#rich-display>`_ mentioned above."
msgid "Addresses of your staging and development builds are derived from this name and assigned automatically. However, when you change your project name, only future builds will use the new name."
msgid "The user group is meant for developers who can make modifications in your code but are not allowed to access the production data. Users of this group cannot connect to the production and staging databases using the *1-click connect* feature, but they can of course use their regular account on these databases if they have one, using their regular credentials."
msgid "These settings are required for **private repositories** only. If you are looking on how to set up your submodules, instructions are available in the chapter :ref:`Submodules <odoosh-advanced-submodules>` of this documentation."
msgid "When a repository is private, it is not possible to publicly download its branches and revisions. For that reason, you need to configure a deploy key for Odoo.sh, so the remote Git server allows our platform to download the revisions of this private repository."
msgid "Additional database workers can be configured here. More workers help increase the load your production database is able to handle. If you add more, it will automatically be synchronized with your subscription."
msgid "Adding more workers will not magically solve all performance issues. It only allows the server to handle more connections at the same time. If some operations are unusually slow, it's most likely a problem with the code, if it's not due to your own customizations you can open a ticket `here <https://www.odoo.com/help>`_."
msgid "Additional staging branches allow you to develop and test more features at the same time. If you add more, it will automatically be synchronized with your subscription."
msgid "Once you have completed the testing and are happy with the result, you decide on a date and time when you stop users from accessing Odoo, freeze all data entries, and create an upgrade request for the production upgrade."
msgid "You restore it in your Production environment a few short hours later and continue working on the newly upgraded database (this is done automatically on Odoo Online)."
msgstr ""
#: ../../content/administration/upgrade.rst:57
msgid ":doc:`Upgrade process for Odoo Online <upgrade/odoo_online>`"
msgstr ""
#: ../../content/administration/upgrade.rst:58
msgid ":doc:`Upgrade process for Odoo.sh <upgrade/odoo_sh>`"
msgstr ""
#: ../../content/administration/upgrade.rst:59
msgid ":doc:`Upgrade process for On-Premise <upgrade/on_premise>`"
msgstr ""
#: ../../content/administration/upgrade.rst:64
msgid "Testing"
msgstr ""
#: ../../content/administration/upgrade.rst:66
msgid "This phase allows you to review an upgraded version of your database without affecting your production database in any way. We suggest that you run the test upgrade process at least once, but you can do it as many times as you need (one at a time)."
msgstr ""
#: ../../content/administration/upgrade.rst:70
msgid "Once you receive your upgraded test database, check that all data, processes, and functionality are still correct and working as expected."
msgstr ""
#: ../../content/administration/upgrade.rst:73
msgid "If you do find discrepancies, :ref:`report your issues <upgrade/test-assistance>` and :ref:`request a new test database <upgrade/test-db-request>` when the reported issues are fixed in the upgrade script."
msgstr ""
#: ../../content/administration/upgrade.rst:77
msgid "If you do not find any discrepancies, you can move on to the upgrade of your production database."
msgstr ""
#: ../../content/administration/upgrade.rst:80
msgid "A test database is only intended for testing and remains completely unrelated to your present or future production database. Any data you add, or changes you make, will not be reflected in your upgraded production database."
msgstr ""
#: ../../content/administration/upgrade.rst:85
msgid "Test databases are neutered and features are disabled to prevent them from having an impact on the production database:"
msgstr ""
#: ../../content/administration/upgrade.rst:88
msgid "The serial number of the database is modified (to prevent it from sending information as if it was the production database)."
msgstr ""
#: ../../content/administration/upgrade.rst:90
msgid "The :ref:`base URL of the database <domain-name/web-base-url>` is reset to ``http://localhost:8069`` and the email domain to ``localhost``."
msgstr ""
#: ../../content/administration/upgrade.rst:92
msgid "Scheduled actions are disabled (the calendar synchronization, the bank statement synchronization, the planned automated actions, the fetching of incoming mail servers, etc.)."
msgstr ""
#: ../../content/administration/upgrade.rst:94
msgid "Outgoing mail servers are disabled by archiving the existing ones and adding a fake/non-working one."
msgstr ""
#: ../../content/administration/upgrade.rst:96
msgid "Payment providers and delivery carriers are reset to test environment."
msgstr ""
#: ../../content/administration/upgrade.rst:97
msgid "Accounting localization Electronic Data Interchange (EDI) services are disabled."
msgstr ""
#: ../../content/administration/upgrade.rst:98
msgid "A system parameter is set to tell the database has been neutered."
msgstr ""
#: ../../content/administration/upgrade.rst:103
msgid "Request a test database"
msgstr ""
#: ../../content/administration/upgrade.rst:105
msgid "Follow the instructions available per hosting type on the `website form <https://upgrade.odoo.com>`_ and select *Testing* purpose."
msgid "Every business and organization has its own operational needs and has to test its specific Odoo database individually. We recommend you look at `the test scenario <https://docs.google.com/document/d/1ypNs7JKPOsjNbKpdiKFH7Al6g6whZ9jr7f7duAQ5E1w/>`_ for further information."
msgid "If you encounter an issue in the **test database**, please get in touch with Odoo Upgrade Support via the `Odoo Support page <https://www.odoo.com/help>`_."
msgid "If you choose another *Ticket Description* type, the request will be redirected to another team. This will slow down the processing and response time."
msgid "Please provide as much detail as you can (i.e., videos and screenshots to illustrate your issue). This will avoid clarifying questions and speed up the resolution process significantly."
msgid "The production upgrade request is when you decide to upgrade your current database with all your production data (invoices, VAT returns, inventories, current orders) to a new version of your choice."
msgid "After your :ref:`tests <upgrade/testing-phase>` are completed to your satisfaction, submit the request to upgrade your production database via our `website form <https://upgrade.odoo.com>`_. Select *Production* purpose."
msgid "Under the *Ticket Description* section, select the appropriate type related to your issue but **do not select** the option *An issue related to my upgrade*."
msgid "If you choose *An issue related to my upgrade* as ticket type, the request will be redirected to another team than the support one and will slow down the processing and response time."
msgid "Should you have any more questions about the upgrade, do not hesitate to send a message to `Odoo Upgrade Team <mailto:upgrade@odoo.com>`_. We will be happy to answer it as soon as possible."
msgid "This is a factor to take into consideration before upgrading. If you are on an older version, we suggest you to prefer the most recent version to benefit from longer support (before having to upgrade again)."
msgid "The Upgrade Service is limited to your database's technical conversion and adaptation (standard modules and data) to make it compatible with the targeted version."
msgid "Whenever you want. You can make your upgrade request as soon as a new version is released or when your version turns unsupported, and you still wish to enjoy support."
msgid "As soon as Odoo announces the release of a new major version, you can create a test upgrade request to try the latest version. Please note that at this point, the upgrade scripts will only have been tested with demo data. Please report any issue you might encounter while testing via the `Odoo Support page <https://www.odoo.com/help>`_ and make sure to be happy with your test version before requesting the upgrade of your database in production."
msgid "In general, the \"smaller\" the database, the quickest the upgrade request is completed. A single-user database that uses only CRM will be processed faster than a multi-company, multi-user database that uses Accounting, Sales, Purchase, and Manufacturing."
msgid "It depends on the user involvement (the time spent on testing, reporting problems, etc.) and the issues encountered that might need to be addressed by our technical team."
msgid "An upgrade is switching to a newer version of Odoo, while a migration reflects the change of :ref:`editions <upgrade-faq/editions-change>` or change of :ref:`hosting type <upgrade-faq/hosting-types-switch>`."
msgid "The upgrade always returns an Enterprise edition of Odoo, whether the database you sent was a community or enterprise edition. It is required to have an enterprise subscription to upgrade."
msgid "When an upgrade request completes successfully (test or production), you receive an email notification about it that includes an 'Upgrade Report'. This report is also sent to you via the Discuss app. It contains valuable information regarding changes that occurred during the upgrade. While it serves as a guide to possible issues to look out for, it is not an exhaustive list. It remains imperative that you test the upgraded database thoroughly and report any discrepancies you might find, before you decide to upgrade your production database."
msgid "During the upgrade, some custom views might get disabled for technical reasons. Therefore they might have to be fixed after the upgrade. The :ref:`Upgrade Report <upgrade-faq/upgrade-report>` that is generated after the upgrade is available in the Discuss app, and lists all the custom views that might be impacted by this."
msgid "Open our `Release Note <https://www.odoo.com/page/release-notes>`_ page to get a summary of the new features and improvements made in each version."
msgid "An Odoo Online test database is available for one month by default. We can extend this trial period upon request. For Odoo.sh or on-premise, there is no restriction."
msgid "As many as needed. When you are comfortable with the database, run a last test upgrade 48 hours before requesting your production upgrade and test your workflows one last time."
msgid "If you encounter issues during the upgrade process, please contact the Odoo Support through the `Odoo Support page <https://www.odoo.com/help>`_."
msgid "Once you have completed testing and are happy with the result, you decide on a date and time when you stop users from accessing Odoo, freeze all data entries, and create an upgrade request for the production upgrade."
msgid "SSL - All web connections to client instances are protected with 256-bit SSL encryption (HTTPS with a 2048-bit modulus SSL certificate), and running behind Grade A SSL stacks. All our certificate chains are using SHA-2 already."
msgid "Safe System - Our servers are running recent Linux distribution with up-to-date security patches, with firewall and intrusion countermeasures (not disclosed for obvious reasons)."
msgid "The uploaded and migrated databases uploaded to the Upgrade platform are kept for up to 3 months and are permanently deleted following that period."
msgid "You can learn more about privacy and data handling at Odoo by visiting our `General Data Protection Regulation page <https://www.odoo.com/gdpr>`_."
msgid "This feature allows customers to upgrade their database directly from a message prompt sent to the database administrator as soon as the new version is released. Odoo first tests the upgrade to the next version. The rolling release upgrade option is displayed if the automated tests are successful. The message offers two options:"
msgid "To take you to your `database manager <https://www.odoo.com/my/databases/>`_ where you can `request an upgraded test database <https://upgrade.odoo.com/#online/>`_ and check the upgraded test database for any discrepancies."
msgid "When you choose to proceed with the production upgrade directly, make sure all users have saved their work and are logged out. The upgrade takes approximately 15 minutes. During this time your database is unreachable. If you notice any problem after the upgrade, please report it via the `Odoo Support page <https://www.odoo.com/help>`_."
msgid "This triggers the automated upgrade process. A confirmation email is then sent to you with the the link to the upgraded database or to provide information if the upgrade failed."
msgid "Switch that branch to the :guilabel:`Staging` branch, **upgrade** the last daily production backup and **test it**. Write upgrade scripts if necessary."
msgid "The first step is to upgrade your custom modules to keep them compatible with the new version. Fork your :guilabel:`Production` branch in the :guilabel:`Development` stage, then go to the settings of your :guilabel:`Development` branch and select the Odoo version you target. If needed, modify your code to be compatible with the new version. Make sure to **test** your features are still working correctly."
msgid "Depending on your contract, the upgrade of your custom modules can be done by yourself, by your Partner or by Odoo (if you hold a subscription including maintenance of customizations)."
msgid "The **latest production daily automatic backup** is sent to the `upgrade platform <https://www.upgrade.odoo.com>`_ to start the upgrade test process."
msgid "When the upgraded backup is ready on the `upgrade platform <https://www.upgrade.odoo.com>`_, it is automatically downloaded back to your project."
msgid "The branch is now in a **special mode**: each time a **commit is pushed** on the branch, a **restore operation** of the upgraded backup occurs, and an **update of all the custom modules** happens. This allows you to quickly iterate on your custom modules upgrade scripts. The log file of the upgrade process can be found at :file:`~/logs/upgrade.log` in your newly upgraded staging build."
msgid "It may happen that custom modules are no longer needed after an upgrade. Custom modules in the upgraded database are set to be updated. If the modules are missing in the code, the update fails, thus failing the whole process. An empty module with a manifest and possibly some custom upgrade script are necessary to clean up the database. The complete removal of the module has to be handled afterwards."
msgid "Now that the test upgraded database is available on your staging branch, **thoroughly test it** and make sure everything runs as it's supposed to. Once you are satisfied with the result, you are ready to upgrade your production database."
msgid "On your :guilabel:`Production` branch, go to the :guilabel:`Upgrade` tab, select the :guilabel:`targeted version` and click on the :guilabel:`start Upgrade` button."
msgid "The actual process is **triggered as soon as you push a new commit** in your branch. Make sure you are pushing code that is compatible with the new version. For example by merging the code from your upgraded staging branch."
msgid "If anything goes wrong, the platform automatically reverts the upgrade, the same as it would be for a regular update. In case of success, a backup is always made."
msgid "The update of your custom modules must be successful to complete the entire upgrade process. Make sure the status of your staging upgrade is :guilabel:`successful` before trying it in production."
msgid "For technically-advanced users and partners, the upgrade process can be initiated via the following command line on the server where the database is hosted:"
msgid "The above command creates the database dump, sends it to the upgrade platform, and initiates the automated upgrade process. During the upgrade, you can follow the live logs on your screen. Once the upgrade process is completed successfully, the upgraded database is restored onto the server (as a duplicate test database)."
msgid "Upload this dump file at https://upgrade.odoo.com and select *Testing* as the aim. Odoo performs the automated upgrade process. Once it is completed, you receive an email with a link to download the upgrade database dump file."
msgid "Once you have completed the testing successfully, you can proceed to upgrade your live database in production. Download your upgraded database from the link in the email and import it onto your live environment."
