Installing Odoo frontend and backend on different servers

January 20, 2018Yenthe666 9 Comments

In this tutorial I will teach you how to separate your Odoo frontend and backend. I will install the Odoo codebase/frontend on one server and the backend (your PostgreSQL server and database) on another server. You will learn how to configure both Odoo and PostgreSQL to achieve this.

1. Introduction

In order to achieve and demonstrate this setup to you I will be working with two virtual machines.
I will refer to the Odoo codebase/frontend server as the ‘frontend server’. The PostgreSQL server and database will be named ‘backend server’ throughout this tutorial.
My frontend server has the IP 192.168.118.167 and my backend server has the IP 192.168.118.168.
Tip: Make sure that both your servers have a fixed IP, otherwise your setup will break due to IP changes!

2. Configuring the backend server

Let us start with the configuration of the backend server. This server will contain the PostgreSQL server and the database(s).

2.1 Installing postgreSQL

Open up a terminal on your backend server and install PostgreSQL if you haven’t yet:

sudo apt-get install postgresql -y

1	sudo apt-get install postgresql -y

2.2 Creating the PostgreSQL user

Now create a new PostgreSQL user. Make sure that the PostgreSQL username matches with the username of the user running Odoo on your frontend server. In my example I will create a new PostgreSQL user with the name “odoo11”:

sudo su - postgres -c "createuser -s odoo11 -P"

1	sudo su - postgres -c "createuser -s odoo11 -P"

After you execute this command the system will ask you for a password for this user. Fill in a password and confirm this password again.
Tip: Don’t forget to remember this password, you’ll need it later on.

2.3 Configuring pg_hba.conf

After installing the PostgreSQL server and creating the user we now need to configure the remote connections. As our backend server will be used for the database connections our frontend server needs to be able to access it. Open up your frontend server and get the IP of the server. In my example my frontend server has the IP 192.168.118.167. Now open up your pg_hba.conf file on your backend server:

sudo nano /etc/postgresql/9.5/main/pg_hba.conf

1	sudo nano /etc/postgresql/9.5/main/pg_hba.conf

Scroll in this file and search for the following line of code:

# IPv4 local connections:
host    all             all             127.0.0.1/32            md5

1 2	# IPv4 local connections: host all all 127.0.0.1/32 md5

Add a new line after the existing one which contains your frontend server its IP address. As you don’t want to use the exact IP address you should use the /24 subdomain. In my example this results to 192.168.118.0/24 instead of 192.168.118.167. Your configuration file should now look like this:

# IPv4 local connections:
host    all             all             127.0.0.1/32            md5
host    all             all             192.168.118.0/24        md5

# IPv4 local connections:

host all all 127.0.0.1/32 md5

host all all 192.168.118.0/24 md5

Finally, save your file and close it. Your PostgreSQL now knows that you want to allow connections from the backend server (IP 192.168.118.167).

2.4 Configuring postgresql.conf

Your PostgreSQL still needs to know the listen address of your frontend server too though. To achieve this we have to edit the postgresql.conf file:

sudo nano /etc/postgresql/9.5/main/postgresql.conf

1	sudo nano /etc/postgresql/9.5/main/postgresql.conf

Find the ‘listen_addresses’ line, which looks like this by default:

#listen_addresses = 'localhost'

1	#listen_addresses = 'localhost'

Now add in the IP of your frontend Odoo server (in my example 192.168.118.192):

listen_addresses = 'localhost,192.168.118.168'

1	listen_addresses = 'localhost,192.168.118.168'

Tip: Don’t forget to remove the # in this line because otherwise this line will be skipped!
Save this file and close it.
You’ve now applied all the changes that you need to do on the backend server. Next reload the PostgreSQL service in order to apply all the changes:

sudo service postgresql reload

1	sudo service postgresql reload

3. Configuring the frontend server

Your backend server is done now. Switch to the frontend server and open up your Odoo configuration file.
Tip: If you haven’t installed an Odoo yet you can follow my tutorial here
Typically your Odoo configuration file is under /etc/ and is named your-odoo.conf:

sudo nano /etc/odoo11-server.conf

1	sudo nano /etc/odoo11-server.conf

Add or change the following parameters in the configuration file:

[options]
admin_passwd = mysupersecretpassword
db_host = 192.168.118.168 # This is the IP of the backend server
db_port = 5432
db_user = odoo11 # The PostgreSQL user you've configured in chapter 2.2.
db_password = yourpassword # The PostgreSQL user his password you've set in chapter 2.2

[options]

admin_passwd = mysupersecretpassword

db_host = 192.168.118.168 # This is the IP of the backend server

db_port = 5432

db_user = odoo11 # The PostgreSQL user you've configured in chapter 2.2.

db_password = yourpassword # The PostgreSQL user his password you've set in chapter 2.2

Finally, restart your Odoo service to reload your Odoo configuration:

sudo service odoo11-server restart

1	sudo service odoo11-server restart

When you now browse to your Odoo instance (on your frontend server) you’ll see that your new Odoo is ready to use.

That is all! You’ve now setup your own Odoo instance where the frontend and backend are split between two servers.

4. Tips

While this is everything that you need in order to split up the backend and frontend of Odoo there are still some things to consider.
Because of security reasons you’ll most likely want to encrypt all the data and place everything on SSL. This also includes the calls from the frontend server to the backend server.
After you’ve created a new database you should check if the database is in fact created on the backend server instead of on the frontend server. You can do this executing the following commands (one by one) on your backend server:

sudo su postgres
psql
\l

sudo su postgres

psql

After running these commands you can see an overview of your databases and to what user the database belongs. In my example you can see a new database named ‘ABC’ which is owned by my Odoo/PostgreSQL user ‘odoo11’:

5. Conclusion

Setting up an Odoo instance where the frontend and the backend are split is actually quite easy. Due to the built-in parameters from Odoo it is very easy to configure the frontend side. When you split the frontend and backend up and apply extra security – such as HTTPS connections and VLAN’s – you’ll have a safer and more controlable Odoo instance.
If you’d like to learn more about the deployment of servers and the default Odoo parameters you can have a look at the official documentation.

Has this tutorial helped you, do you have any feedback or questions? Post away!

Configuring and using Odoo.sh

January 19, 2018Yenthe666 3 Comments

In this tutorial I will learn you how to setup an Odoo.sh account, how to configure Odoo.sh and how to tests your code automatically with Odoo.sh.
In this example I will create a new account, create a new repository and add code to the Github repository in order to explain how Odoo.sh works.

1. Creating an Odoo.sh account

Go to odoo.sh and click on the “Sign in” button at the top:

When you click on the “Sign in button” you’ll get an authorize screen from Github. If you’re not yet logged in on Github it will ask you to login, if you’re already logged in on Github you’ll get the authorize screen. Click on “Authorize odoo”:

After you click on “Authorize odoo” Github will ask for additional permissions. Click on “Authorize Odoo” again to give the additional permissions. Because of these additional permissions Odoo.sh can follow all changes and handle it automatically for you.

Now Odoo will ask you to deploy your platform. Choose an existing repository if you want to use it or create a new one. In this tutorial I will create a new repository to show everything in detail. Choose a repository name. Next choose the Odoo version you want to test against and finally provide your enterprise (or partner) license. The hosting location is up to you. Finally click on “Deploy”:

Thats it! You’ve just registered your own Odoosh account and connected Github to Odoosh!

2. The Odoo.sh main screen

After you’ve clicked on “Deploy” you’ll now see the main screen of Odoo.sh.

In the left menu you will see the title “DEVELOPMENT”. Under this section you will see every branch you’ve made on this Github repository. If I would create a second branch named “11.0” I would see “11.0” and “master” in the left menu. At the top you’ll see a main menubar with the options “Branches”, “Builds”, “Status” and “Settings.

The Branches tab opens the main page, from where you can see everything related to your branches. This includes the mails, shell access to the test instance and access to the logs.
The Builds tab opens a page where you can see all your test instances. This is almost identical to the Odoo runbot (at runbot.odoo.com).
The Status tab opens a page where you can see all the statistics of the Odoo.sh platform. It shows you the uptime and the status of all the servers.
The Settings tab opens a page where you can configure advanced settings. You can add collaborators, set a project name (and URL), add submodules and much more.

3. Github

Now open up your Github and go to your (just created) repository. Add a commit to the repository so that it contains some (new) code. In my example I will push a module to Github that contains an automated test so I can show you how tests work and what happens. If you’d like to do the same you can take my example module from Github. The moment that you make a commit to the Github repository Odoo.sh will detect this and it will start up a test environment because of the new commit. My Github after making a commit:

My Odoo.sh a few seconds after making this commit:

4. Checking the commit

Now switch back to Odoo.sh. After a few minutes your new commit will procude a new test instance that is ready and built. In my example I’ve deliberately added an error in my last commit so as a result you can see the test fail. When the test instance is done, typically after a few minutes, you’ll see the result in the main screen:

So now my test has failed it means I must have done something wrong. I’ve figured out what was wrong and I correct my test. After correcting this test I make a new commit to Github. After a few seconds you’ll see that Odoo.sh automatically detects and tests this new commit again:

5. Odoo.sh builds and test instances

Finally go to the builds page by clicking on “Builds” in the top menu bar. After you click on “Builds” you will see an overview of all your test instances and if they succeeded or not:

From this page you can directly connect to a test instance in order to test functionalities or ‘play’ with Odoo.
When a test has failed (such as “INIT: Add demo module wit…” in my screenshot) you can click on the exclamation icon, next to the connect button, to see why your instance has failed:

Tip: If you want to see the full log of the instance you can do this by clicking on the “…” icon at the top of a build and selecting “Logs”. From here you can download and view all logs. Alternatively you can also do this from the “Branches” page by clicking on the “Logs” menu.

6. Conclusion

As Odoo.sh is very big and has a lot of options I’ve decided to split the content in two tutorials. Because of this the first blog post, this one, is only about basic operations. You can find a second tutorial about how to configure public and private submodules here.

Odoo.sh is a very powerfull platform to use. Odoo has invested a lot of time into Odoo.sh and due to this it is an advanced system that allows you to quickly (and easily!) use test instances with Odoo. Thanks to Odoo.sh you no longer need your own runbot instance and complex hardware setup as you can get it all out of the box.

Has this tutorial helped you, do you have any feedback or questions? Post away!

Creating automated tests in Odoo

January 10, 2018Yenthe666 10 Comments

In this tutorial I will learn you how to write tests, how to use the tests in Odoo and how to test them. I will create an example test that creates a new project, a new task and attaches the project to the new task.
Tip: This tutorial is based on Odoo V11 but will also work in V10.

1. Creating a new module

Let us create a new module to start. You can either manually create a module or create one with the scaffold command from Odoo. Now that you’ve created your module you should add the dependency to the module where you want to create a test for. In this tutorial I will create a test for the project module so I’ll add a dependency for ‘project’. Add your depends in the manifest.py (or __openerp__.py in V10):

'depends': ['project'],

1	'depends': ['project'],

2. Creating the Python files

After you’ve created your new module you should create a new folder named ‘tests’. Create a new Python file for the test, in this example I’ll create a new file named ‘test_project.py’.
Tip: The filename of a Python test should always start with ‘test_’ or it will not be executed! Your folder structure should now look like this:
Tests folder structure

Next create a new Python file named __init__.py and import the Python file ‘test_project’ in it:

# -*- coding: utf-8 -*-

from . import test_project

# -*- coding: utf-8 -*-

from . import test_project

Your folder structure should now look like this:
Complete tests folder structure
Tip: You should not import the tests folder in the main __init__.py file. Odoo tests are an exception and have a built-in check by Odoo. They do not need an explicit import like models or controllers.

3. Creating the class and adding imports

Now open up your ‘test_project.py’ file again and let us start by adding the import and creating the class structure!
In order to write a test you should import ‘odoo.tests’ and you should create a new class with a TransactionCase. Have a look at this code:

# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.

from odoo.tests import common


class TestProject(common.TransactionCase):

# -*- coding: utf-8 -*-

# Part of Odoo. See LICENSE file for full copyright and licensing details.

from odoo.tests import common

class TestProject(common.TransactionCase):

So, does this make sense to you? We simply import the default Odoo framework options for tests with ‘from odoo.tests import common’. We then create a new class in which we add ‘common.TransactionCase’. The ‘common.TransactionCase’ tells Odoo that we want to test a transaction and that we want to do a rollback of this record after the test is done.

4. Writing the tests

Now that we have the basic structure setup there is just one more thing to do: write a function in which you want to do your tests. Go ahead and create a new function in your file.
Tip: Function names for tests should always start with ‘test_’ or they will not be run by Odoo!

Finally, write the test cases you’d like in this function. In my example I will create a test that creates a new project, then creates a new task and then adds the project to the task. Have a look at this piece of code:

    def test_create_data(self):
        # Create a new project with the test
        test_project = self.env['project.project'].create({
            'name': 'TestProject'
        })

        # Add a test task to the project
        test_project_task = self.env['project.task'].create({
            'name': 'ExampleTask',
            'project_id': test_project.id
        })

        # Check if the project name and the task name match
        self.assertEqual(test_project.name, 'TestProject')
        self.assertEqual(test_project_task.name, 'ExampleTask')
        # Check if the project assigned to the task is in fact the correct id
        self.assertEqual(test_project_task.project_id.id, test_project.id)
        # Do a little print to show it visually for this demo - in production you don't really need this.
        print('Your test was succesfull!')

def test_create_data(self):

# Create a new project with the test

test_project = self.env['project.project'].create({

'name': 'TestProject'

})

# Add a test task to the project

test_project_task = self.env['project.task'].create({

'name': 'ExampleTask',

'project_id': test_project.id

})

# Check if the project name and the task name match

self.assertEqual(test_project.name, 'TestProject')

self.assertEqual(test_project_task.name, 'ExampleTask')

# Check if the project assigned to the task is in fact the correct id

self.assertEqual(test_project_task.project_id.id, test_project.id)

# Do a little print to show it visually for this demo - in production you don't really need this.

print('Your test was succesfull!')

So, does this make sense to you? A lot of the code looks the same as if you’re writing custom code. With self.env[‘project.project’].create({}) we’ll create a new project named ‘TestProject’. With self.env[‘project.task’].create({}) we’ll create a new task named ‘ExampleTask’ and we will assign the project to this task, thanks to the ‘test_project’ variable.
If you would run this code it would create a new project and task and the moment the test is finished the transaction is rolled back (so there is no record in the database).

4.1 Understanding assertEqual

The final part of my code shows some assertEqual calls, so what do these calls do? assertEqual is made available by default in Odoo to test and compare values. For example:

self.assertEqual(test_project.name, 'TestProject')

1	self.assertEqual(test_project.name, 'TestProject')

This will test if the just created project record it’s name is indeed named ‘TestProject’. In the second assertEqual I check if the task name is in fact ‘ExampleTask’. And, finally, in the third assertEqual I check if the project attached to the task is indeed the right project:

self.assertEqual(test_project_task.project_id.id, test_project.id)

1	self.assertEqual(test_project_task.project_id.id, test_project.id)

The first variable of assertEqual is always the value you’ve gotten back from the test and the second part is the result that you’re expecting. If there is a difference in those two the test will fail.

5. Running / testing the test

So now we’ve coded the whole test but how do we run and test it? In order to run a test you should use the ‘–test-enable’ parameter and the ‘-i’ parameter to say which module(s) you want to test. If you want to test this in your local Odoo instance you will need to run your Odoo from the terminal like this:

./odoo-bin -i automated_test_demo --test-enable -c /etc/odoo11-server.conf

1 2	./odoo-bin -i automated_test_demo --test-enable -c /etc/odoo11-server.conf

If you have a runbot instance (or use Odoo.sh) the tests will be executed automatically and you will see if the test succeeded or failed right away. An example of Odoo.sh:
Odoo.sh status example
An example of a runbot instance:
Runbot status example

When you just run the tests locally you can see if the test succeeded or failed in the logfile. Open up your logfile after you’ve ran the test and have a look at the output:

INFO Newest odoo.addons.automated_test_demo.tests.test_project: Ran 1 test in 0.566s
INFO Newest odoo.addons.automated_test_demo.tests.test_project: OK

1 2	INFO Newest odoo.addons.automated_test_demo.tests.test_project: Ran 1 test in 0.566s INFO Newest odoo.addons.automated_test_demo.tests.test_project: OK

If you add a print statement in the test, like in my example, you will also see it printed in the terminal:
Succesfull test

5.1 Making a test fail

We’ve now seen how to create a test and how to run it, but how exactly does a failed test look?
Open up your test again and change the assertEqual from this:

self.assertEqual(test_project.name, 'TestProject')

1	self.assertEqual(test_project.name, 'TestProject')

to this:

self.assertEqual(test_project.name, 'TestProject11')

1	self.assertEqual(test_project.name, 'TestProject11')

Run the test from your terminal again with -i your_module –test-enable in the command. You’ll see that the print statement is no longer printed in your terminal. Now open up your logfile again after your Odoo is loaded. You’ll now find a failure in the logfile:

ERROR Newest odoo.addons.automated_test_demo.tests.test_project: ` AssertionError: 'TestProject' != 'TestProject11'
INFO Newest odoo.addons.automated_test_demo.tests.test_project: Ran 1 test in 1.741s
ERROR Newest odoo.addons.automated_test_demo.tests.test_project: FAILED
INFO Newest odoo.addons.automated_test_demo.tests.test_project:  (failures=1)

ERROR Newest odoo.addons.automated_test_demo.tests.test_project: ` AssertionError: 'TestProject' != 'TestProject11'

INFO Newest odoo.addons.automated_test_demo.tests.test_project: Ran 1 test in 1.741s

ERROR Newest odoo.addons.automated_test_demo.tests.test_project: FAILED

INFO Newest odoo.addons.automated_test_demo.tests.test_project: (failures=1)

This shows you that the input ‘TestProject’ does not match what we expect (‘TestProject11’) and because of this our test failed.
If you would commit these changes to Github and if you’re using a runbot or Odoo.sh you’ll also see a failed instance after this.

6. Conclusion

Writing and using tests in Odoo is quite easy to do. It is a great feature to use if you’re writing a lot of custom code and want to keep overview. Thanks to Odoo.sh and runbots it is also very easy to follow up on your tests and to see if something has broken or not. Sadly at this point running tests locally isn’t very easy to follow up though so you might want to consider setting up a runbot or Odoo.sh account.
Do you want to try the demo code and see the source code of this tutorial? You can view it on my Github account.
Has this tutorial helped you, do you have any feedback or questions? Post away!

Creating a tour in Odoo

January 9, 2018Yenthe666 4 Comments

In this tutorial I will teach you how to create a tour in Odoo. You will learn how to create a tour step by step in JavaScript and how to guide your users through your custom development.
In this tutorial I will create a new tour throughout the contacts app in order to guide a new user through this module.

1. Creating a new module

Let us create a new module to start. You can either manually create a module or create one with the scaffold command from Odoo. Now that you’ve created your module you should add the dependency to the module where you want to create a tour. In this tutorial I will create a tour that guides the user through the contacts app.

2. Creating the tour

The first thing to do in order to create a tour is to create a JavaScript file. In Odoo you should place all JavaScript code under /static/src/js so create these folders first. Create these new folders and then create a new JavaScript file named ‘tour.js’. You should now have this:
JavaScript folder structure
Now open up your JS file and define a new function. In this function you should require ‘web.core’ and ‘web.core.tour’ and include ‘core._t’ in order to manage translations later on. Your code should now look like this:

odoo.define('example.tour', function(require) {
"use strict";

var core = require('web.core');
var tour = require('web_tour.tour');

var _t = core._t;
});

odoo.define('example.tour', function(require) {

"use strict";

var core = require('web.core');

var tour = require('web_tour.tour');

var _t = core._t;

});

2.1. Registering the tour

You now have the basic JavaScript structure! It is time to register a tour and add steps to this tour. Just have a look at this code for a minute:

odoo.define('example.tour', function(require) {
"use strict";

var core = require('web.core');
var tour = require('web_tour.tour');

var _t = core._t;

tour.register('example_tour', {
    url: "/web",
}, [tour.STEPS.MENU_MORE, {
    trigger: '.o_app[data-menu-xmlid="contacts.menu_contacts"]',
    content: _t('Want to <b>create customers</b>?<br/><i>Click on Contacts to start.</i>'),
    position: 'bottom',
}
}]);
});

odoo.define('example.tour', function(require) {

"use strict";

var core = require('web.core');

var tour = require('web_tour.tour');

var _t = core._t;

tour.register('example_tour', {

url: "/web",

}, [tour.STEPS.MENU_MORE, {

trigger: '.o_app[data-menu-xmlid="contacts.menu_contacts"]',

content: _t('Want to <b>create customers</b>?<br/><i>Click on Contacts to start.</i>'),

position: 'bottom',

}

}]);

});

Does this make any sense to you? Let us walk over it line by line. The tour.register function will tell Odoo that you want to add a new tour to Odoo. ‘example_tour’ is the technical name of the tour, but be sure that it is unique! The next line shows “url” which tells Odoo on which page the tour should start (in this tutorial from the home screen). ‘tour.STEPS.MENU_MORE’ is built in in Odoo to know where/when/how the tour should be loaded.

Finally, you’ll see the options ‘trigger’, ‘content’ and ‘position’. The ‘trigger’ will tell Odoo when exactly that you would want to trigger the tour step. In this example our tour would start on the main Odoo screen and will show a little icon under the contacts app. If you would install the app with this piece of code you would get the following result:
Tour home screen

The ‘content’ will show a text dialog to the enduser and the ‘position’ tells Odoo where exactly to show this text (top, right, left or bottom).

2.2 Choosing your tour steps

A tour should contain multiple steps and a logical flow though. Take a minute to figure out the steps you would like your users to follow in your tour.
In this tutorial I will add the following steps:
– The moment the user clicks on ‘Contacts’ and when the Kanban view opens we’ll show a hint to click on the ‘Create’ button.
– After clicking on the ‘Create’ button we’ll show a hint to fill in the name of the contact.
– When the name of the contact is filled in we’ll show a hint to click on ‘Save’.

2.3 Creating all tour steps

So, how do we code all the steps? Just have a look at the full code for a minute:

tour.register('example_tour', {
    url: "/web",
}, [tour.STEPS.MENU_MORE, {
    trigger: '.o_app[data-menu-xmlid="contacts.menu_contacts"]',
    content: _t('Want to <b>create customers</b>?<br/><i>Click on Contacts to start.</i>'),
    position: 'bottom',
}, {
    trigger: '.o-kanban-button-new',
    content: _t('Let\'s create your first contact.'),
    position: 'bottom',
    width: 200,
}, {
    // The trigger will tell that you would like to input a value in the field 'Name'
    trigger: 'input[placeholder="Name"]',
    extra_trigger: '.o_form_editable',
    // This is the 'hint' / tooltip that is shown to the enduser
    content: _t('Fill in the name of the contact.'),
    // When you run the test (from the developer tools) it will automatically fill in 'James Cook' automatically)
    run: 'text James Cook',
    position: 'right',
}, {
    trigger: '.o_form_button_save',
    content: _t('Save this contact and the modifications you\'ve made to it.'),
    position: 'bottom',
}]);

tour.register('example_tour', {

url: "/web",

}, [tour.STEPS.MENU_MORE, {

trigger: '.o_app[data-menu-xmlid="contacts.menu_contacts"]',

content: _t('Want to <b>create customers</b>?<br/><i>Click on Contacts to start.</i>'),

position: 'bottom',

}, {

trigger: '.o-kanban-button-new',

content: _t('Let\'s create your first contact.'),

position: 'bottom',

width: 200,

}, {

// The trigger will tell that you would like to input a value in the field 'Name'

trigger: 'input[placeholder="Name"]',

extra_trigger: '.o_form_editable',

// This is the 'hint' / tooltip that is shown to the enduser

content: _t('Fill in the name of the contact.'),

// When you run the test (from the developer tools) it will automatically fill in 'James Cook' automatically)

run: 'text James Cook',

position: 'right',

}, {

trigger: '.o_form_button_save',

content: _t('Save this contact and the modifications you\'ve made to it.'),

position: 'bottom',

}]);

If you would run this code it would do exactly the points that I’ve subscribed. The trigger tells when the next step should go off. For example with the trigger ‘.o-kanban-button-new’ it will show a blinking icon next to the ‘Create’ button. Have you noticed the ‘extra_trigger’ option and the ‘run’ option in the third step? By setting an ‘extra_trigger’ Odoo knows when the trigger should go off (in this case after the user clicked on create so he is in edit mode). The ‘run’ option will tell Odoo to automatically fill in text in the field that we’ve put a trigger on, in this example the field ‘name’. If we would run (play) the tour from the Odoo interface it would now automatically fill in the name of the new contact.
That is all! You’ve now got the JavaScript code to create a tour.

3. Including the JavaScript

Finally you should now include your JavaScript file so that it gets compiled in Odoo too. Create a new xml file named ‘assets.xml’ in a new folder ‘views’:
Assets folder structure

Open up the XML file, inherit the assets template and insert the tour.js file into the assets. Your code should look like this:

<?xml version="1.0"?>
<odoo>
    <template id="assets_backend" name="tour_demo assets" inherit_id="web.assets_backend">
        <xpath expr="." position="inside">
            <!-- Include the new tour in the JavaScript assets -->
            <script type="text/javascript" src="/tour_demo/static/src/js/tour.js"></script>
        </xpath>
    </template>
</odoo>

<?xml version="1.0"?>

<odoo>

</xpath>

</template>

</odoo>

Now open up your manifest.py (or openerp.py if you’re in V10) and add the ‘assets.xml’ file to the data key so that it gets loaded too:

'data': [
    'views/assets.xml',
]

'data': [

'views/assets.xml',

]

That’s it, you’ve created your very first tour! If you save this code and run the module you will get the following behaviour:

4. Translating the tour

Now what if you have Odoo users that speak different languages? Luckily you can also translate tours to any language. Activate developer mode and then go to ‘Settings’ > ‘Translations’ > ‘Export translation’. You’ll now see a dialog from which you can choose the target language and where you can select your app. Select your target language, choose the file format ‘PO File’ and choose your app. Finally click on ‘Export’:
Export translations

Next create a new folder named ‘i18n’ and add your downloaded file to this folder:
Translation folder structure
Finally, open up the PO file and translate all the terms:
Translation example
When you now update your module and switch to another language you’ll see that the tour is translated.

5. Conclusion

Because of the built-in framework from Odoo it is very easy to create a tour for users. With this tour you can guide a new user through your own custom development in a matter of minutes and with personalised text. Creating tours is really quick and just takes a few lines of code.
Do you want to try the demo code and see the source code of this tutorial? You can view it on my Github account.
Has this tutorial helped you, do you have any feedback or questions? Post away!

Configuring app settings with erppeek in Odoo 11

November 18, 2017Yenthe666 Leave a comment

In this tutorial I will teach you how to automatically configure app settings with erppeek in Odoo 11. You will learn how to use the erppeek library and how to configure app settings from Python code. By doing so you can automate the configuration of your database(s).
In this tutorial I will configure the sales app to use different units of measure through Python code.
Tip: This tutorial will only work for Odoo 11. The concept will work for Odoo 8, 9 and 10 too but the code will be slightly different.

1. Installing erppeek

Before we can start using erppeek we will need to install it. Open up a Linux terminal and run the following command:

sudo pip install erppeek

1	sudo pip install erppeek

After running this command we can access and use erppeek.

2. Creating the Python script

Now create a new Python file on your system where you would like to save your new script:

sudo nano db_configurer.py

1	sudo nano db_configurer.py

2.1 Configuring the settings

Now that we have a new file we have to import erppeek, so we can access all the possibilities of the erppeek library:

import erppeek

1	import erppeek

The next step is to tell erppeek where it can find the database and how it can access it. In order to do this we will have to tell the library the database name, the location of the database, the username and the password. Add the following code to your script, under the import:

database = 'YourDatabase'
server = 'http://localhost:8069'
admin_password = 'admin'
user = 'admin'

database = 'YourDatabase'

server = 'http://localhost:8069'

admin_password = 'admin'

user = 'admin'

Tip: If you can you should use this script with the administrator user only, since this user has access to all models and settings.

2.2 Connecting to the database

So now that we’ve installed erppeek, we’ve imported the library and we’ve created the configuration the next step is to connect to the Odoo database in order to query and configure it. Just connect to the Odoo client:

# Connect to the database
client = erppeek.Client(server, database, user, admin_password)

1 2	# Connect to the database client = erppeek.Client(server, database, user, admin_password)

This line will tell your script to which server, on which database we want to connect with what user and sets the user his password.
Thanks to this code we can now access the database and query it. We now just have to find the record that contains settings of this database and then do the actions we would like to execute.

2.3 Getting the Odoo configuration

In Odoo 11 all settings are saved in the model ‘res.config.settings’ so let us get data from this model:

config_id = client.model('res.config.settings').search([], limit=1, order='id desc')

1	config_id = client.model('res.config.settings').search([], limit=1, order='id desc')

So, what exactly does this code do? It tells erppeek that we want to get data from the model ‘res.config.settings’ and that we only want to get the last record from this model (limit=1, order=’id desc’ will do that).
The result will now be in the variable ‘config_id’ but there is a catch. What if this query didn’t return anything? Imagine that you have a database that you’ve just installed and you’ve never done any settings, in this case the variable config_id won’t contain any records. To prevent our script from crashing we should make an if/else statement now that handles this potential issue. Let us start with the if statement!

2.4 Setting the new configuration

If we find a result we should set the changes that we want to activate and we then have to apply them on the database. Have a look at this code:

if config_id:
    # This means there is already a configuration record - let us write on it
    config_record = client.model('res.config.settings').browse(config_id[0])
    config_record.write({'group_uom': True})
    # Execute the record in order to trigger the save and to apply the values
    config_record.execute()

if config_id:

# This means there is already a configuration record - let us write on it

config_record = client.model('res.config.settings').browse(config_id[0])

config_record.write({'group_uom': True})

# Execute the record in order to trigger the save and to apply the values

config_record.execute()

So, what exactly does this do? The first line will get the record itself, as ‘config_id’ only contains the id for the record but not the record itself. By calling the Odoo database and using the ‘browse’ function (with the ‘config_id’ passed in the call) we will get the record back. When we have this record we can write our wanted changes on this record. In this case I will configure Odoo to use different units of measures. Remember that all settings in Odoo are booleans, so we do {‘group_uom’: True} to set the boolean to true. But, where did I get the ‘group_uom’ from? This is the field of this setting. You can get this by activating the developer mode and hovering over the field:
Field name configuration
In this screenshot you can see that the option is not yet activated, so the boolean is set to False. {‘group_uom’: True} will change this when we apply this value. This is exactly what the last line does! By calling the record its execute function we will tell Odoo to execute this change and apply it to Odoo.
If you would run this script and would go to the settings you would see that the units of measures is now activated.

2.5 Setting the configuration when there is no record yet

Now we should handle one more case. When there has never been any configuration record yet we should create one. Just have a look at the following code:

else:
    # This means there is no configuration yet - let us make a new record
    config_record = client.model('res.config.settings').create({})
    config_record.write({'group_uom': True})
    config_record.execute()

else:

# This means there is no configuration yet - let us make a new record

config_record = client.model('res.config.settings').create({})

config_record.write({'group_uom': True})

config_record.execute()

The code is almost identical to the if part (in chapter 2.4) with the minor change that we create a new and empty record with .create({}) in order to create new settings. Besides of this difference the rest of the code is identical to the if part of the code.

2.6 Running the file

Good job! You’re almost done. Now save your Python file and execute the python script to apply the setting(s) on your Odoo database. Execute the following command:

python db_configurer.py

1	python db_configurer.py

After a few seconds your script will be done. Now open up your Odoo, go to the configuration and you will see that the setting has been applied to your database:
Applied configuration
That’s it! You’ve now configured your own Odoo database settings with a simple Python script!

3. Conclusion

Thanks to the erppeek library you can easily configure app settings from a Python script. With this library you can automate your databases its settings in a matter of seconds. If you would like to learn more about erppeek and the options it offers you should have a look at the official documentation.
Do you want to try the demo code and see the source code of this tutorial? You can view it on my Github account.
Has this tutorial helped you, do you have any feedback or questions? Post away!

Installing Odoo 11 (enterprise) on Ubuntu

October 8, 2017Yenthe666 75 Comments

In this tutorial I will learn you how to install Odoo 11 community or enterprise on Ubuntu 16.04. The script that you will use is based on the code from André Schenkels but has been updated, upgraded and improved. Do notice that if you want to install the enterprise version that you will need to be an official partner or that you need to have bought the enterprise subscription from Odoo. Otherwise you will have no access to the Github repository for the enterprise code!

1. Downloading the script

The first step is to download my script from Github and to add the code in a new .sh file on your Ubuntu machine, wherever you’d like this.
For example right under /home. Open up an Ubuntu terminal and cd to the directory where you’d like to keep the script and then create the file:

sudo wget https://raw.githubusercontent.com/Yenthe666/InstallScript/11.0/odoo_install.sh

1	sudo wget https://raw.githubusercontent.com/Yenthe666/InstallScript/11.0/odoo_install.sh

If you’re curious about how the whole code looks and works you can find it on my Github account.
Now open up the file and edit the parameters to your liking:

sudo nano odoo_install.sh

1	sudo nano odoo_install.sh

There are some things you can configure/change to your likings at the top of the script. You can choose if you wish to install Wkhtmltopdf or not, which version you’d like, where the location is and most importantly what the master admin password is.
Tip: always modify this for every Odoo you install!
If you want the enterprise version of V11 you should change the line IS_ENTERPRISE to true:

IS_ENTERPRISE="True"

1	IS_ENTERPRISE="True"

If you want the community version you can just continue and keep the IS_ENTERPRISE key on “False” (which is the case by default):

IS_ENTERPRISE="False"

1	IS_ENTERPRISE="False"

2. Making the Odoo installation file executable

The next step is to make this file executable. After you’ve made it executable you can execute it and everything will be installed automatically.
do this with the following command:

sudo chmod +x odoo_install.sh

1	sudo chmod +x odoo_install.sh

3.Running the script

Now that the code is in your file and the file is executable you simply have to execute it with the following command:

./odoo_install.sh

1	./odoo_install.sh

You will see that the script automatically starts updates, downloads required packages, creates the user, downloads the code from Github, … Eventually, if you’ve chosen to install the enterprise version, you will need to give in your Github credentials to download the enterprise code (since this is a private repository). Fill in your details and let the script continue:
Odoo 9 enterprise authentication
Give the script a few minutes to configure and install everything and eventually you will see something like this:
Result install script

You now have a fully functional Odoo V11 community or enterprise on your system! Congratulations.

4. Extra information about Odoo 11 Enterprise

Since Odoo Enterprise uses code from both http://github.com/odoo/odoo and http://github.com/odoo/enterprise we will separate the code with this script. This will make future upgrades easier and the code is nicely separated. This means that the default V11 code will be under /odoo/odoo-server/ and all the enterprise code will be under /odoo/enterprise/.

In the script you saw there was an option to change the Odoo port (OE_PORT). When you’d change this port number to 8070 in the install script it would be applied to /etc/your-config-file.conf and this would give you the ability to change the default port.
To apply these changes you should do the following:
Changing Odoo settings
The -c will change the configuration and memorize what you’ve changed under /etc/your-config-file.conf. Because my port was set to 8070 this is telling the Odoo that it should run on port 8070. When you would now open up your browser and navigate to http://localhost:8070/ you will see it is running there:
Odoo V9 alternative port

Has this tutorial helped you, do you have any feedback or questions? Post away!

1. Introduction

2. Configuring the backend server

2.1 Installing postgreSQL

2.2 Creating the PostgreSQL user

2.3 Configuring pg_hba.conf

2.4 Configuring postgresql.conf

3. Configuring the frontend server

4. Tips

5. Conclusion

Share this:

Like this:

1. Creating an Odoo.sh account

2. The Odoo.sh main screen

3. Github

4. Checking the commit

5. Odoo.sh builds and test instances

6. Conclusion

Share this:

Like this:

1. Creating a new module

2. Creating the Python files

3. Creating the class and adding imports

4. Writing the tests

4.1 Understanding assertEqual

5. Running / testing the test

5.1 Making a test fail

6. Conclusion

Share this:

Like this:

1. Creating a new module

2. Creating the tour

2.1. Registering the tour

2.2 Choosing your tour steps

2.3 Creating all tour steps

3. Including the JavaScript

4. Translating the tour

5. Conclusion

Share this:

Like this:

1. Installing erppeek

2. Creating the Python script

2.1 Configuring the settings

2.2 Connecting to the database

2.3 Getting the Odoo configuration

2.4 Setting the new configuration

2.5 Setting the configuration when there is no record yet

2.6 Running the file

3. Conclusion

Share this:

Like this:

1. Downloading the script

2. Making the Odoo installation file executable

3.Running the script

4. Extra information about Odoo 11 Enterprise

Share this:

Like this: