diff --git a/addons/account/models/account.py b/addons/account/models/account.py
index 078c504eb43..1a4609b3cb7 100644
--- a/addons/account/models/account.py
+++ b/addons/account/models/account.py
@@ -4,7 +4,7 @@ import time
 import math
 
 from odoo.osv import expression
-from odoo.tools.float_utils import float_round as round, float_is_zero as is_zero
+from odoo.tools.float_utils import float_round as round
 from odoo.tools import DEFAULT_SERVER_DATETIME_FORMAT
 from odoo.exceptions import UserError, ValidationError
 from odoo import api, fields, models, _
@@ -848,7 +848,6 @@ class AccountTax(models.Model):
             price_unit * quantity eventually affected by previous taxes (if tax is include_base_amount XOR price_include)
         """
         self.ensure_one()
-        price_include = self._context.get('force_price_include', self.price_include)
         if self.amount_type == 'fixed':
             # Use copysign to take into account the sign of the base amount which includes the sign
             # of the quantity and the sign of the price_unit
@@ -862,11 +861,11 @@ class AccountTax(models.Model):
                 return math.copysign(quantity, base_amount) * self.amount
             else:
                 return quantity * self.amount
-        if (self.amount_type == 'percent' and not price_include) or (self.amount_type == 'division' and self.price_include):
+        if (self.amount_type == 'percent' and not self.price_include) or (self.amount_type == 'division' and self.price_include):
             return base_amount * self.amount / 100
-        if self.amount_type == 'percent' and price_include:
+        if self.amount_type == 'percent' and self.price_include:
             return base_amount - (base_amount / (1 + self.amount / 100))
-        if self.amount_type == 'division' and not price_include:
+        if self.amount_type == 'division' and not self.price_include:
             return base_amount / (1 - self.amount / 100) - base_amount
 
     @api.multi
@@ -900,58 +899,13 @@ class AccountTax(models.Model):
                 'analytic': boolean,
             }]
         } """
-
-        # 1) Flatten the taxes.
-
-        def collect_taxes(self, all_taxes=None):
-            # Collect all the taxes recursively ordered by the sequence.
-            # Example:
-            # group | seq | sub-group |
-            # ------------|-----------|
-            #       |  1  |           |
-            # ------------|-----------|
-            #   t   |  2  |  | seq |  |
-            #       |     |  |  4  |  |
-            #       |     |  |  5  |  |
-            #       |     |  |  6  |  |
-            #       |     |           |
-            # ------------|-----------|
-            #       |  3  |           |
-            # ------------|-----------|
-            # Result: 1-4-5-6-3
-            if not all_taxes:
-                all_taxes = self.env['account.tax']
-            for tax in self.sorted(key=lambda r: r.sequence):
-                if tax.amount_type == 'group':
-                    all_taxes = collect_taxes(tax.children_tax_ids, all_taxes)
-                else:
-                    all_taxes += tax
-            return all_taxes
-
-        taxes = collect_taxes(self)
-
-        # 2) Avoid dealing with taxes mixing price_include=False && include_base_amount=True
-        # with price_include=True
-
-        base_excluded_flag = False  # price_include=False && include_base_amount=True
-        included_flag = False  # price_include=True
-        for tax in taxes:
-            if tax.price_include:
-                included_flag = True
-            elif tax.include_base_amount:
-                base_excluded_flag = True
-            if base_excluded_flag and included_flag:
-                raise UserError(_('Unable to mix any taxes being price included with taxes affecting the base amount but not included in price.'))
-
-        # 3) Deal with the rounding methods
-
         if len(self) == 0:
             company_id = self.env.user.company_id
         else:
             company_id = self[0].company_id
         if not currency:
             currency = company_id.currency_id
-
+        taxes = []
         # By default, for each tax, tax amount will first be computed
         # and rounded at the 'Account' decimal precision for each
         # PO/SO/invoice line and then these rounded amounts will be
@@ -976,135 +930,50 @@ class AccountTax(models.Model):
         if not round_tax:
             prec += 5
 
-        # 4) Iterate the taxes in the reversed sequence order to retrieve the initial base of the computation.
-        #     tax  |  base  |  amount  |
-        # /\ ----------------------------
-        # || tax_1 |  XXXX  |          | <- we are looking for that, it's the total_excluded
-        # || tax_2 |        |          |
-        # || tax_3 |        |          |
-        # ||  ...  |   ..   |    ..    |
-        #    ----------------------------
-
-        base = round(price_unit * quantity, prec)
-
-        # Keep track of subsequent recomputed bases in order to avoid some rounding issues.
-        # For example, 399.99 computed with a tax 20% price_include leads to
-        # base = 399.99 / 1.2 = 333.32500000000005
-        # tax_amount = base * 0.2 = 66.665
-        # round(base) + round(tax_amount) = 333.33 + 66.67 = 400.0 (!= 399.99: WRONG)
-        #
-        # To fix such issues, base_gaps will contains amount between two bases.
-        # In our example, the gap between 333.32500000000005 and 399.99 is 66.66499999999996
-        #
-        # Then, when processing the tax and because 66.665 - 66.66499999999996 is close to zero,
-        # the real gap is returned and so:
-        # tax_amount = 66.66499999999996
-        # round(base) + round(tax_amount) = 333.33 + 66.66 = 399.99 (CORRECT)
-        base_gaps = []
-
-        def recompute_base(base_amount, fixed_amount, percent_amount):
-            # Recompute the new base amount based on included fixed/percent amount and the current base amount.
-            # Example:
-            #  tax  |  amount  |
-            # ------------------
-            # tax_1 |   10%    |
-            # tax_2 |   15     |
-            # tax_3 |   20%    |
-            # ------------------
-            # if base_amount = 145, the new base is computed as:
-            # (145 - 15) / (1.0 + ((10 + 20) / 100.0)) = 130 / 1.3 = 100
-            if fixed_amount == 0.0 and percent_amount == 0.0:
-                return base_amount
-            new_base = (base_amount - fixed_amount) / (1.0 + percent_amount / 100.0)
-            base_gaps.append(base_amount - new_base)
-            return new_base
-
-        # For the computation of move lines, we could have a negative base value.
-        # In this case, compute all with positive values and negative them at the end.
-        if base < 0:
-            base = -base
-            sign = -1
+        base_values = self.env.context.get('base_values')
+        if not base_values:
+            total_excluded = total_included = base = round(price_unit * quantity, prec)
         else:
-            sign = 1
+            total_excluded, total_included, base = base_values
 
-        # Keep track of the accumulated included fixed/percent amount.
-        incl_fixed_amount = incl_percent_amount = 0
-        for tax in reversed(taxes):
-            if tax.include_base_amount:
-                base = recompute_base(base, incl_fixed_amount, incl_percent_amount)
-                incl_fixed_amount = incl_percent_amount = 0
-            if self._context.get('force_price_include', tax.price_include):
-                if tax.amount_type == 'fixed':
-                    incl_fixed_amount += quantity * tax.amount
-                elif tax.amount_type == 'percent':
-                    incl_percent_amount += tax.amount
-        # Start the computation of accumulated amounts at the total_excluded value.
-        total_excluded = total_included = base = recompute_base(base, incl_fixed_amount, incl_percent_amount)
+        # Sorting key is mandatory in this case. When no key is provided, sorted() will perform a
+        # search. However, the search method is overridden in account.tax in order to add a domain
+        # depending on the context. This domain might filter out some taxes from self, e.g. in the
+        # case of group taxes.
+        for tax in self.sorted(key=lambda r: r.sequence):
+            if tax.amount_type == 'group':
+                children = tax.children_tax_ids.with_context(base_values=(total_excluded, total_included, base))
+                ret = children.compute_all(price_unit, currency, quantity, product, partner)
+                total_excluded = ret['total_excluded']
+                base = ret['base'] if tax.include_base_amount else base
+                total_included = ret['total_included']
+                tax_amount = total_included - total_excluded
+                taxes += ret['taxes']
+                continue
 
-        # 5) Iterate the taxes in the sequence order to fill missing base/amount values.
-        #      tax  |  base  |  amount  |
-        # ||  ----------------------------
-        # ||  tax_1 |   OK   |   XXXX   |
-        # ||  tax_2 |  XXXX  |   XXXX   |
-        # ||  tax_3 |  XXXX  |   XXXX   |
-        # \/  ...   |   ..   |    ..    |
-        #     ----------------------------
-
-        def compute_amount(tax):
-            # Compute the amount of the tax but don't deal with the price_include because it's already
-            # took into account on the base amount except for 'division' tax:
-            # (tax.amount_type == 'percent' && not tax.price_include)
-            # == (tax.amount_type == 'division' && tax.price_include)
-            # N.B: don't use the with_context if force_price_include already False in context
-            if 'force_price_include' not in self._context or self._context['force_price_include']:
-                tax = tax.with_context(force_price_include=False)
-
-            # In case of price_included tax, subtract the amount to the corresponding
-            # gap between the current base and the next one.
-            amount = tax._compute_amount(base, price_unit, quantity, product, partner)
-
-            if not tax.price_include or not base_gaps:
-                return amount
-
-            # Compute the new gap after subtracting of the tax amount
-            new_gap = base_gaps[-1] - amount
-
-            # If the newly computed gap is very close of zero, return the current gap to avoid
-            # rounding issues (see comments above base_gaps).
-            if is_zero(new_gap, prec):
-                return base_gaps.pop()
-
-            # Update the current gap with the new one
-            base_gaps[-1] = new_gap
-            return amount
-
-        taxes_vals = []
-        for tax in taxes:
-            tax_amount = compute_amount(tax)
+            tax_amount = tax._compute_amount(base, price_unit, quantity, product, partner)
             if not round_tax:
                 tax_amount = round(tax_amount, prec)
             else:
                 tax_amount = currency.round(tax_amount)
 
-            # Suppose:
-            # seq | amount | incl | incl_base | base | amount
-            # -----------------------------------------------
-            #  1  |   10 % |   t  |     t     | 100.0 | 10.0
-            # -----------------------------------------------
-            # ... the next computation must be done using 100.0 + 10.0 = 110.0 as base but
-            # the tax base of this tax will be 100.0.
+            if tax.price_include:
+                total_excluded -= tax_amount
+                base -= tax_amount
+            else:
+                total_included += tax_amount
+
+            # Keep base amount used for the current tax
             tax_base = base
+
             if tax.include_base_amount:
                 base += tax_amount
 
-            # The total_included amount is computed as the sum of total_excluded with all tax_amount
-            total_included += tax_amount
-
-            taxes_vals.append({
+            taxes.append({
                 'id': tax.id,
                 'name': tax.with_context(**{'lang': partner.lang} if partner else {}).name,
-                'amount': sign * tax_amount,
-                'base': round(sign * tax_base, prec),
+                'amount': tax_amount,
+                'base': tax_base,
                 'sequence': tax.sequence,
                 'account_id': tax.account_id.id,
                 'refund_account_id': tax.refund_account_id.id,
@@ -1112,10 +981,10 @@ class AccountTax(models.Model):
             })
 
         return {
-            'taxes': taxes_vals,
-            'total_excluded': sign * (currency.round(total_excluded) if round_total else total_excluded),
-            'total_included': sign * (currency.round(total_included) if round_total else total_included),
-            'base': round(sign * base, prec),
+            'taxes': sorted(taxes, key=lambda k: k['sequence']),
+            'total_excluded': currency.round(total_excluded) if round_total else total_excluded,
+            'total_included': currency.round(total_included) if round_total else total_included,
+            'base': base,
         }
 
     @api.model
diff --git a/addons/account/models/account_invoice.py b/addons/account/models/account_invoice.py
index f760bdca07d..1ba5597c1e1 100644
--- a/addons/account/models/account_invoice.py
+++ b/addons/account/models/account_invoice.py
@@ -3,6 +3,7 @@
 import json
 import re
 import uuid
+from functools import partial
 
 from lxml import etree
 from dateutil.relativedelta import relativedelta
@@ -10,6 +11,7 @@ from werkzeug.urls import url_encode
 
 from odoo import api, exceptions, fields, models, _
 from odoo.tools import float_is_zero, float_compare, pycompat
+from odoo.tools.misc import formatLang
 
 from odoo.exceptions import AccessError, UserError, RedirectWarning, ValidationError, Warning
 
@@ -1407,13 +1409,18 @@ class AccountInvoice(models.Model):
     @api.multi
     def _get_tax_amount_by_group(self):
         self.ensure_one()
+        currency = self.currency_id or self.company_id.currency_id
+        fmt = partial(formatLang, self.with_context(lang=self.partner_id.lang).env, currency_obj=currency)
         res = {}
         for line in self.tax_line_ids:
             res.setdefault(line.tax_id.tax_group_id, {'base': 0.0, 'amount': 0.0})
             res[line.tax_id.tax_group_id]['amount'] += line.amount
             res[line.tax_id.tax_group_id]['base'] += line.base
         res = sorted(res.items(), key=lambda l: l[0].sequence)
-        res = [(l[0].name, l[1]['amount'], l[1]['base']) for l in res]
+        res = [(
+            r[0].name, r[1]['amount'], r[1]['base'],
+            fmt(r[1]['amount']), fmt(r[1]['base']),
+        ) for r in res]
         return res
 
 
diff --git a/addons/account/tests/test_tax.py b/addons/account/tests/test_tax.py
index 806c0e5cda4..4ca0f8c6ab1 100644
--- a/addons/account/tests/test_tax.py
+++ b/addons/account/tests/test_tax.py
@@ -1,7 +1,4 @@
-# -*- coding: utf-8 -*-
-
 from odoo.addons.account.tests.account_test_users import AccountTestUsers
-
 import time
 
 
@@ -28,12 +25,6 @@ class TestTax(AccountTestUsers):
             'amount': 10,
             'sequence': 3,
         })
-        self.percent_tax_bis = self.tax_model.create({
-            'name': "Percent tax bis",
-            'amount_type': 'percent',
-            'amount': 21,
-            'sequence': 3,
-        })
         self.division_tax = self.tax_model.create({
             'name': "Division tax",
             'amount_type': 'division',
@@ -74,125 +65,47 @@ class TestTax(AccountTestUsers):
         self.bank_account = self.bank_journal.default_debit_account_id
         self.expense_account = self.env['account.account'].search([('user_type_id.type', '=', 'payable')], limit=1) #Should be done by onchange later
 
-    def _check_compute_all_results(self, base, total_included, total_excluded, taxes, res):
-        self.assertAlmostEqual(res['base'], base)
-        self.assertAlmostEqual(res['total_included'], total_included)
-        self.assertAlmostEqual(res['total_excluded'], total_excluded)
-        for i in range(0, len(taxes)):
-            self.assertAlmostEqual(res['taxes'][i]['base'], taxes[i][0])
-            self.assertAlmostEqual(res['taxes'][i]['amount'], taxes[i][1])
-
     def test_tax_group_of_group_tax(self):
         self.fixed_tax.include_base_amount = True
+        self.group_tax.include_base_amount = True
+        self.group_of_group_tax.include_base_amount = True
         res = self.group_of_group_tax.compute_all(200.0)
-        self._check_compute_all_results(
-            220,    # 'base'
-            263,    # 'total_included'
-            200,    # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 10.0),    # |  1  |    10  |      |     t
-                (210.0, 21.0),    # |  3  |    10% |      |
-                (210.0, 10.0),    # |  1  |    10  |      |     t
-                (220.0, 22.0),    # |  3  |    10% |      |
-                # ---------------------------------------------------
-            ],
-            res
-        )
+        self.assertEquals(res['total_excluded'], 200.0)
+        # After calculation of first group
+        # base = 210
+        # total_included = 231
+        # Base of the first grouped is passed
+        # Base after the second group (220) is dropped.
+        # Base of the group of groups is passed out,
+        # so we obtain base as after first group
+        self.assertEquals(res['base'], 210.0)
+        self.assertEquals(res['total_included'], 263.0)
 
     def test_tax_group(self):
         res = self.group_tax.compute_all(200.0)
-        self._check_compute_all_results(
-            200,    # 'base'
-            230,    # 'total_included'
-            200,    # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 10.0),    # |  1  |    10  |      |
-                (200.0, 20.0),    # |  3  |    10% |      |
-                # ---------------------------------------------------
-            ],
-            res
-        )
+        self.assertEquals(res['total_excluded'], 200.0)
+        self.assertEquals(res['total_included'], 230.0)
+        self.assertEquals(len(res['taxes']), 2)
+        self.assertEquals(res['taxes'][0]['amount'], 10.0)
+        self.assertEquals(res['taxes'][1]['amount'], 20.0)
 
     def test_tax_percent_division(self):
         self.division_tax.price_include = True
         self.division_tax.include_base_amount = True
-        res_division = self.division_tax.compute_all(200.0)
-        self._check_compute_all_results(
-            220,    # 'base'
-            220,    # 'total_included'
-            200,    # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 20.0),    # |  4  |    10/ |   t  |     t
-                # ---------------------------------------------------
-            ],
-            res_division
-        )
         self.percent_tax.price_include = False
         self.percent_tax.include_base_amount = False
+        res_division = self.division_tax.compute_all(200.0)
         res_percent = self.percent_tax.compute_all(200.0)
-        self._check_compute_all_results(
-            200,    # 'base'
-            220,    # 'total_included'
-            200,    # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 20.0),    # |  3  |    10% |      |
-                # ---------------------------------------------------
-            ],
-            res_percent
-        )
+        self.assertEquals(res_division['taxes'][0]['amount'], 20.0)
+        self.assertEquals(res_percent['taxes'][0]['amount'], 20.0)
         self.division_tax.price_include = False
         self.division_tax.include_base_amount = False
-        res_division = self.division_tax.compute_all(200.0)
-        self._check_compute_all_results(
-            200,     # 'base'
-            222.22,  # 'total_included'
-            200,     # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 22.22),   # |  4  |    10/ |      |
-                # ---------------------------------------------------
-            ],
-            res_division
-        )
         self.percent_tax.price_include = True
         self.percent_tax.include_base_amount = True
+        res_division = self.division_tax.compute_all(200.0)
         res_percent = self.percent_tax.compute_all(200.0)
-        self._check_compute_all_results(
-            200,     # 'base'
-            200,     # 'total_included'
-            181.82,  # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (181.82, 18.18),  # |  3  |    10% |   t  |     t
-                # ---------------------------------------------------
-            ],
-            res_percent
-        )
-        self.percent_tax_bis.price_include = True
-        self.percent_tax_bis.include_base_amount = True
-        res_percent = self.percent_tax_bis.compute_all(7.0)
-        self._check_compute_all_results(
-            7.0,   # 'base'
-            7.0,   # 'total_included'
-            5.79,  # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (5.79, 1.21),     # |  3  |    21% |   t  |     t
-                # ---------------------------------------------------
-            ],
-            res_percent
-        )
+        self.assertEquals(res_division['taxes'][0]['amount'], 22.22)
+        self.assertEquals(res_percent['taxes'][0]['amount'], 18.18)
 
     def test_tax_sequence_normalized_set(self):
         self.division_tax.sequence = 1
@@ -200,103 +113,19 @@ class TestTax(AccountTestUsers):
         self.percent_tax.sequence = 3
         taxes_set = (self.group_tax | self.division_tax)
         res = taxes_set.compute_all(200.0)
-        self._check_compute_all_results(
-            200,     # 'base'
-            252.22,  # 'total_included'
-            200,     # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 22.22),   # |  1  |    10/ |      |
-                (200.0, 10.0),    # |  2  |    10  |      |
-                (200.0, 20.0),    # |  3  |    10% |      |
-                # ---------------------------------------------------
-            ],
-            res
-        )
+        self.assertEquals(res['taxes'][0]['amount'], 22.22)
+        self.assertEquals(res['taxes'][1]['amount'], 10.0)
+        self.assertEquals(res['taxes'][2]['amount'], 20.0)
 
     def test_tax_include_base_amount(self):
         self.fixed_tax.include_base_amount = True
         res = self.group_tax.compute_all(200.0)
-        self._check_compute_all_results(
-            210,     # 'base'
-            231,     # 'total_included'
-            200,     # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 10.0),    # |  1  |    10  |      |     t
-                (210.0, 21.0),    # |  3  |    10% |      |
-                # ---------------------------------------------------
-            ],
-            res
-        )
-
-        self.fixed_tax.price_include = True
-        self.fixed_tax.include_base_amount = False
-        res = self.fixed_tax.compute_all(100.0, quantity=2.0)
-        self._check_compute_all_results(
-            180,     # 'base'
-            200,     # 'total_included'
-            180,     # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (180.0, 20.0),    # |  1  |    20  |      |     t
-                # ---------------------------------------------------
-            ],
-            res
-        )
-
-    def test_tax_include_base_amount_2(self):
-        self.percent_tax.price_include = True
-        self.percent_tax.amount = 21.0
-        res = self.percent_tax.compute_all(7.0)
-        self._check_compute_all_results(
-            5.79,     # 'base'
-            7.0,      # 'total_included'
-            5.79,     # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (5.79, 1.21),     # |  3  |    10% |   t  |
-                # ---------------------------------------------------
-            ],
-            res
-        )
-
-    def test_tax_include_base_amount_3(self):
-        self.percent_tax.price_include = True
-        self.percent_tax.amount = 20.0
-        res = self.percent_tax.compute_all(399.99)
-        self._check_compute_all_results(
-            333.33,     # 'base'
-            399.99,     # 'total_included'
-            333.33,     # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (333.33, 66.66),  # |  3  |    10% |   t  |
-                # ---------------------------------------------------
-            ],
-            res
-        )
+        self.assertEquals(res['total_included'], 231.0)
 
     def test_tax_currency(self):
         self.division_tax.amount = 15.0
         res = self.division_tax.compute_all(200.0, currency=self.env.ref('base.VEF'))
-        self._check_compute_all_results(
-            200,       # 'base'
-            235.2941,  # 'total_included'
-            200,       # 'total_excluded'
-            [
-                # base , amount      | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (200.0, 35.2941),  # |  4  |    15/ |      |
-                # ---------------------------------------------------
-            ],
-            res
-        )
+        self.assertAlmostEqual(res['total_included'], 235.2941)
 
     def test_tax_move_lines_creation(self):
         """ Test that creating a move.line with tax_ids generates the tax move lines and adjust line amount when a tax is price_include """
@@ -327,7 +156,6 @@ class TestTax(AccountTestUsers):
         }
         move = self.env['account.move'].with_context(apply_taxes=True).create(vals)
 
-
         aml_fixed_tax = move.line_ids.filtered(lambda l: l.tax_line_id.id == self.fixed_tax.id)
         aml_percent_tax = move.line_ids.filtered(lambda l: l.tax_line_id.id == self.percent_tax.id)
         aml_fixed_tax_bis = move.line_ids.filtered(lambda l: l.tax_line_id.id == self.fixed_tax_bis.id)
@@ -337,62 +165,7 @@ class TestTax(AccountTestUsers):
         self.assertEquals(aml_percent_tax.credit, 20)
         self.assertEquals(len(aml_fixed_tax_bis), 1)
         self.assertEquals(aml_fixed_tax_bis.credit, 15)
-        
+
         aml_with_taxes = move.line_ids.filtered(lambda l: set(l.tax_ids.ids) == set([self.group_tax.id, self.fixed_tax_bis.id]))
         self.assertEquals(len(aml_with_taxes), 1)
         self.assertEquals(aml_with_taxes.credit, 190)
-
-    def test_advanced_taxes_computation_0(self):
-        '''Test more advanced taxes computation (see issue 34471).'''
-        tax_1 = self.env['account.tax'].create({
-            'name': 'test_advanced_taxes_computation_0_1',
-            'amount_type': 'percent',
-            'amount': 10,
-            'price_include': True,
-            'include_base_amount': True,
-            'sequence': 1,
-        })
-        tax_2 = self.env['account.tax'].create({
-            'name': 'test_advanced_taxes_computation_0_2',
-            'amount_type': 'percent',
-            'amount': 10,
-            'sequence': 2,
-        })
-        tax_3 = self.env['account.tax'].create({
-            'name': 'test_advanced_taxes_computation_0_3',
-            'amount_type': 'percent',
-            'amount': 10,
-            'price_include': True,
-            'sequence': 3,
-        })
-        tax_4 = self.env['account.tax'].create({
-            'name': 'test_advanced_taxes_computation_0_4',
-            'amount_type': 'percent',
-            'amount': 10,
-            'sequence': 4,
-        })
-        tax_5 = self.env['account.tax'].create({
-            'name': 'test_advanced_taxes_computation_0_5',
-            'amount_type': 'percent',
-            'amount': 10,
-            'price_include': True,
-            'sequence': 5,
-        })
-        taxes = tax_1 + tax_2 + tax_3 + tax_4 + tax_5
-        res = taxes.compute_all(132.0)
-        self._check_compute_all_results(
-            110,     # 'base'
-            154,     # 'total_included'
-            100,     # 'total_excluded'
-            [
-                # base , amount     | seq | amount | incl | incl_base
-                # ---------------------------------------------------
-                (100.0, 10.0),    # |  1  |    10% |   t  |     t
-                (110.0, 11.0),    # |  2  |    10% |      |
-                (110.0, 11.0),    # |  3  |    10% |   t  |
-                (110.0, 11.0),    # |  4  |    10% |      |
-                (110.0, 11.0),    # |  5  |    10% |   t  |
-                # ---------------------------------------------------
-            ],
-            res
-        )
diff --git a/addons/account/views/report_invoice.xml b/addons/account/views/report_invoice.xml
index dd152c1540e..687bef2b250 100644
--- a/addons/account/views/report_invoice.xml
+++ b/addons/account/views/report_invoice.xml
@@ -115,18 +115,18 @@
                                             <t t-if="len(o.tax_line_ids) == 1 and o.amount_untaxed == amount_by_group[2]">
                                                 <td><span t-esc="amount_by_group[0]"/></td>
                                                 <td class="text-right">
-                                                    <span t-esc="amount_by_group[1]" t-options='{"widget": "monetary", "display_currency": o.currency_id}'/>
+                                                    <span t-esc="amount_by_group[3]"/>
                                                 </td>
                                             </t>
                                             <t t-else="">
                                                 <td>
                                                     <span t-esc="amount_by_group[0]"/>
                                                     <span>&amp;nbsp;<span>on</span>
-                                                        <t t-esc="amount_by_group[2]" t-options='{"widget": "monetary", "display_currency": o.currency_id}'/>
+                                                        <t t-esc="amount_by_group[4]"/>
                                                     </span>
                                                 </td>
                                                 <td class="text-right">
-                                                    <span t-esc="amount_by_group[1]" t-options='{"widget": "monetary", "display_currency": o.currency_id}'/>
+                                                    <span t-esc="amount_by_group[3]" />
                                                 </td>
                                             </t>
                                         </tr>
diff --git a/addons/im_livechat/report/im_livechat_report_operator_views.xml b/addons/im_livechat/report/im_livechat_report_operator_views.xml
index 85ba2f28284..43c00e1757c 100644
--- a/addons/im_livechat/report/im_livechat_report_operator_views.xml
+++ b/addons/im_livechat/report/im_livechat_report_operator_views.xml
@@ -36,7 +36,6 @@
                         <filter name="group_by_channel" string="Channel" domain="[]" context="{'group_by':'channel_id'}"/>
                         <filter name="group_by_operator" string="Operator" domain="[('partner_id','!=', False)]" context="{'group_by':'partner_id'}"/>
                         <separator orientation="vertical" />
-                        <filter name="group_by_hour" string="Creation date (hour)" domain="[]" context="{'group_by':'start_date_hour'}"/>
                         <filter name="group_by_day" string="Creation date (day)" domain="[]" context="{'group_by':'start_date:day'}"/>
                         <filter name="group_by_week" string="Creation date (week)" domain="[]" context="{'group_by':'start_date:week'}"/>
                         <filter name="group_by_month" string="Creation date (month)" domain="[]" context="{'group_by':'start_date:month'}" />
diff --git a/addons/l10n_fr_fec/wizard/account_fr_fec.py b/addons/l10n_fr_fec/wizard/account_fr_fec.py
index 871dd856bfc..3f2a6471c86 100644
--- a/addons/l10n_fr_fec/wizard/account_fr_fec.py
+++ b/addons/l10n_fr_fec/wizard/account_fr_fec.py
@@ -169,8 +169,9 @@ class AccountFrFec(models.TransientModel):
             '''
 
         sql_query += '''
-        GROUP BY aml.account_id
+        GROUP BY aml.account_id, aat.type
         HAVING sum(aml.balance) != 0
+        AND aat.type not in ('receivable', 'payable')
         '''
         formatted_date_from = self.date_from.replace('-', '')
         date_from = datetime.strptime(self.date_from, DEFAULT_SERVER_DATE_FORMAT)
@@ -208,6 +209,64 @@ class AccountFrFec(models.TransientModel):
                 unaffected_earnings_results[5] = unaffected_earnings_account.name
             w.writerow(unaffected_earnings_results)
 
+        # INITIAL BALANCE - receivable/payable
+        sql_query = '''
+        SELECT
+            'OUV' AS JournalCode,
+            'Balance initiale' AS JournalLib,
+            'OUVERTURE/' || %s AS EcritureNum,
+            %s AS EcritureDate,
+            MIN(aa.code) AS CompteNum,
+            replace(MIN(aa.name), '|', '/') AS CompteLib,
+            CASE WHEN rp.ref IS null OR rp.ref = ''
+            THEN COALESCE('ID ' || rp.id, '')
+            ELSE rp.ref
+            END
+            AS CompAuxNum,
+            COALESCE(replace(rp.name, '|', '/'), '') AS CompAuxLib,
+            '-' AS PieceRef,
+            %s AS PieceDate,
+            '/' AS EcritureLib,
+            replace(CASE WHEN sum(aml.balance) <= 0 THEN '0,00' ELSE to_char(SUM(aml.balance), '999999999999999D99') END, '.', ',') AS Debit,
+            replace(CASE WHEN sum(aml.balance) >= 0 THEN '0,00' ELSE to_char(-SUM(aml.balance), '999999999999999D99') END, '.', ',') AS Credit,
+            '' AS EcritureLet,
+            '' AS DateLet,
+            %s AS ValidDate,
+            '' AS Montantdevise,
+            '' AS Idevise,
+            MIN(aa.id) AS CompteID
+        FROM
+            account_move_line aml
+            LEFT JOIN account_move am ON am.id=aml.move_id
+            LEFT JOIN res_partner rp ON rp.id=aml.partner_id
+            JOIN account_account aa ON aa.id = aml.account_id
+            LEFT JOIN account_account_type aat ON aa.user_type_id = aat.id
+        WHERE
+            am.date < %s
+            AND am.company_id = %s
+            AND aat.include_initial_balance = 't'
+            AND (aml.debit != 0 OR aml.credit != 0)
+        '''
+
+        # For official report: only use posted entries
+        if self.export_type == "official":
+            sql_query += '''
+            AND am.state = 'posted'
+            '''
+
+        sql_query += '''
+        GROUP BY aml.account_id, aat.type, rp.ref, rp.id
+        HAVING sum(aml.balance) != 0
+        AND aat.type in ('receivable', 'payable')
+        '''
+        self._cr.execute(
+            sql_query, (formatted_date_year, formatted_date_from, formatted_date_from, formatted_date_from, self.date_from, company.id))
+
+        for row in self._cr.fetchall():
+            listrow = list(row)
+            account_id = listrow.pop()
+            w.writerow([s.encode("utf-8") for s in listrow])
+
         # LINES
         sql_query = '''
         SELECT
diff --git a/addons/mail/tests/test_mail_channel.py b/addons/mail/tests/test_mail_channel.py
index cabfe99203b..9469e7b4879 100644
--- a/addons/mail/tests/test_mail_channel.py
+++ b/addons/mail/tests/test_mail_channel.py
@@ -42,7 +42,7 @@ class TestMailGroup(TestMail):
         def mail_group_message_get_recipient_values(self, notif_message=None, recipient_ids=None):
             return self.env['mail.thread'].message_get_recipient_values(notif_message=notif_message, recipient_ids=recipient_ids)
         cls.env['mail.channel']._patch_method('message_get_recipient_values', mail_group_message_get_recipient_values)
-        super(TestMail, cls).tearDownClass()
+        super(TestMailGroup, cls).tearDownClass()
 
     @mute_logger('odoo.addons.base.ir.ir_model', 'odoo.models')
     def test_access_rights_public(self):
diff --git a/addons/mass_mailing/static/src/js/mass_mailing_editor.js b/addons/mass_mailing/static/src/js/mass_mailing_editor.js
index 5190cd00838..7705e62fa9e 100644
--- a/addons/mass_mailing/static/src/js/mass_mailing_editor.js
+++ b/addons/mass_mailing/static/src/js/mass_mailing_editor.js
@@ -321,7 +321,6 @@ snippets_editor.Class.include({
             switch_theme.last = theme_params;
 
             $body.removeClass(all_classes).addClass(theme_params.className);
-            switch_images(theme_params, $editable_area);
 
             var $old_layout = $editable_area.find(".o_layout");
             // This wrapper structure is the only way to have a responsive and
@@ -351,8 +350,9 @@ snippets_editor.Class.include({
                 $contents = $editable_area.contents();
             }
 
-            $editable_area.empty().append($new_layout);
             $new_wrapper_content.append($contents);
+            switch_images(theme_params, $new_wrapper_content);
+            $editable_area.empty().append($new_layout);
             $old_layout.remove();
 
             if (first_choice) {
diff --git a/addons/mrp/report/mrp_production_templates.xml b/addons/mrp/report/mrp_production_templates.xml
index c94536371e0..d17a8b18fb7 100644
--- a/addons/mrp/report/mrp_production_templates.xml
+++ b/addons/mrp/report/mrp_production_templates.xml
@@ -71,8 +71,7 @@
                                 </tr>
                                 <tr t-foreach="o.move_raw_ids" t-as="line">
                                     <td>
-                                        <span t-field="line.product_id.code"/>
-                                        <span t-field="line.product_id.name"/>
+                                        <span t-field="line.product_id"/>
                                     </td>
                                     <td class="text-right">
                                         <span t-field="line.product_uom_qty"/>
diff --git a/addons/payment_stripe/controllers/main.py b/addons/payment_stripe/controllers/main.py
index 27b36a902bf..8ccdfc935f9 100644
--- a/addons/payment_stripe/controllers/main.py
+++ b/addons/payment_stripe/controllers/main.py
@@ -66,5 +66,5 @@ class StripeController(http.Controller):
         response = tx._create_stripe_charge(tokenid=post['tokenid'], email=post['email'])
         _logger.info('Stripe: entering form_feedback with post data %s', pprint.pformat(response))
         if response:
-            request.env['payment.transaction'].sudo().form_feedback(response, 'stripe')
+            request.env['payment.transaction'].sudo().with_context(lang=None).form_feedback(response, 'stripe')
         return post.pop('return_url', '/')
diff --git a/addons/point_of_sale/static/src/js/models.js b/addons/point_of_sale/static/src/js/models.js
index adb4919f0e3..15b866aba30 100644
--- a/addons/point_of_sale/static/src/js/models.js
+++ b/addons/point_of_sale/static/src/js/models.js
@@ -88,7 +88,7 @@ exports.PosModel = Backbone.Model.extend({
 
         // We fetch the backend data on the server asynchronously. this is done only when the pos user interface is launched,
         // Any change on this data made on the server is thus not reflected on the point of sale until it is relaunched.
-        // when all the data has loaded, we compute some stuff, and declare the Pos ready to be used.
+        // when all the data has loaded, we compute some stuff, and declare the Pos ready to be used. 
         this.ready = this.load_server_data().then(function(){
             return self.after_load_server_data();
         });
@@ -205,7 +205,7 @@ exports.PosModel = Backbone.Model.extend({
         },
     },{
         model:  'account.tax',
-        fields: ['name','amount', 'price_include', 'include_base_amount', 'amount_type', 'children_tax_ids', 'sequence'],
+        fields: ['name','amount', 'price_include', 'include_base_amount', 'amount_type', 'children_tax_ids'],
         domain: null,
         loaded: function(self, taxes){
             self.taxes = taxes;
@@ -1647,159 +1647,74 @@ exports.Orderline = Backbone.Model.extend({
 
         return tax;
     },
-    /**
-     * Mirror JS method of:
-     * _compute_amount in addons/account/models/account.py
-     */
-    _compute_all: function(tax, base_amount, quantity, price_include) {
-        if(price_include === undefined)
-            price_include = tax.price_include;
+    _compute_all: function(tax, base_amount, quantity) {
         if (tax.amount_type === 'fixed') {
             var sign_base_amount = base_amount >= 0 ? 1 : -1;
             return (Math.abs(tax.amount) * sign_base_amount) * quantity;
         }
-        if ((tax.amount_type === 'percent' && !price_include) || (tax.amount_type === 'division' && tax.price_include)){
+        if ((tax.amount_type === 'percent' && !tax.price_include) || (tax.amount_type === 'division' && tax.price_include)){
             return base_amount * tax.amount / 100;
         }
-        if (tax.amount_type === 'percent' && price_include){
+        if (tax.amount_type === 'percent' && tax.price_include){
             return base_amount - (base_amount / (1 + tax.amount / 100));
         }
-        if (tax.amount_type === 'division' && !price_include) {
+        if (tax.amount_type === 'division' && !tax.price_include) {
             return base_amount / (1 - tax.amount / 100) - base_amount;
         }
         return false;
     },
-    /**
-     * Mirror JS method of:
-     * compute_all in addons/account/models/account.py
-     *
-     * Read comments in the python side method for more details about each sub-methods.
-     */
     compute_all: function(taxes, price_unit, quantity, currency_rounding, no_map_tax) {
         var self = this;
-
-        // 1) Flatten the taxes.
-
-        var _collect_taxes = function(taxes, all_taxes){
-            taxes.sort(function (tax1, tax2) {
-                return tax1.sequence - tax2.sequence;
-            });
-            _(taxes).each(function(tax){
-                if(tax.amount_type === 'group')
-                    all_taxes = _collect_taxes(tax.children_tax_ids, all_taxes);
-                else
-                    all_taxes.push(tax);
-            });
-            return all_taxes;
-        }
-        var collect_taxes = function(taxes){
-            return _collect_taxes(taxes, []);
-        }
-
-        taxes = collect_taxes(taxes);
-
-        // 2) Avoid dealing with taxes mixing price_include=False && include_base_amount=True
-        // with price_include=True
-
-        var base_excluded_flag = false; // price_include=False && include_base_amount=True
-        var included_flag = false;      // price_include=True
-        _(taxes).each(function(tax){
-            if(tax.price_include)
-                included_flag = true;
-            else if(tax.include_base_amount)
-                base_excluded_flag = true
-            if(base_excluded_flag && included_flag)
-                throw new Error('Unable to mix any taxes being price included with taxes affecting the base amount but not included in price.');
-        });
-
-        // 3) Deal with the rounding methods
-
+        var list_taxes = [];
         var currency_rounding_bak = currency_rounding;
         if (this.pos.company.tax_calculation_rounding_method == "round_globally"){
            currency_rounding = currency_rounding * 0.00001;
         }
-
-        // 4) Iterate the taxes in the reversed sequence order to retrieve the initial base of the computation.
-
-        var base = round_pr(price_unit * quantity, currency_rounding);
-
-        var base_gaps = [];
-
-        var recompute_base = function(base_amount, fixed_amount, percent_amount){
-            if(fixed_amount === 0.0 && percent_amount === 0.0)
-                return base_amount;
-             var new_base = (base_amount - fixed_amount) / (1.0 + percent_amount / 100.0);
-             base_gaps.push(base_amount - new_base);
-             return new_base;
-        }
-
-        var sign = 1;
-        if(base < 0){
-            base = -base;
-            sign = -1;
-        }
-
-        var incl_fixed_amount = 0.0;
-        var incl_percent_amount = 0.0;
-       _(taxes.reverse()).each(function(tax){
-            if(tax.include_base_amount){
-                base = recompute_base(base, incl_fixed_amount, incl_percent_amount);
-                incl_fixed_amount = 0.0;
-                incl_percent_amount = 0.0;
+        var total_excluded = round_pr(price_unit * quantity, currency_rounding);
+        var total_included = total_excluded;
+        var base = total_excluded;
+        _(taxes).each(function(tax) {
+            if (!no_map_tax){
+                tax = self._map_tax_fiscal_position(tax);
             }
-            if(tax.price_include){
-                if(tax.amount_type === 'fixed')
-                    incl_fixed_amount += quantity * tax.amount;
-                else if(tax.amount_type === 'percent')
-                    incl_percent_amount += tax.amount;
+            if (!tax){
+                return;
             }
-        });
+            if (tax.amount_type === 'group'){
+                var ret = self.compute_all(tax.children_tax_ids, price_unit, quantity, currency_rounding);
+                total_excluded = ret.total_excluded;
+                base = ret.total_excluded;
+                total_included = ret.total_included;
+                list_taxes = list_taxes.concat(ret.taxes);
+            }
+            else {
+                var tax_amount = self._compute_all(tax, base, quantity);
+                tax_amount = round_pr(tax_amount, currency_rounding);
 
-        base = recompute_base(base, incl_fixed_amount, incl_percent_amount);
-        var total_excluded = base;
-        var total_included = base;
-
-        // 5) Iterate the taxes in the sequence order to fill missing base/amount values.
-
-        var compute_amount = function(tax){
-            var amount = self._compute_all(tax, base, quantity, false);
-
-            if(!tax.price_include || base_gaps.length == 0)
-                return amount;
-
-            var new_gap = base_gaps[base_gaps.length - 1] - amount;
-
-            if(round_pr(new_gap, currency_rounding) === 0.0)
-                return base_gaps.pop();
-
-            base_gaps[base_gaps.length - 1] = new_gap;
-            return amount;
-        };
-
-        var taxes_vals = [];
-        _(taxes.reverse()).each(function(tax){
-            var tax_amount = compute_amount(tax);
-            tax_amount = round_pr(tax_amount, currency_rounding);
-
-            var tax_base = base;
-
-            if(tax.include_base_amount)
-                base += tax_amount;
-
-            total_included += tax_amount;
-
-            var tax_vals = {
-                id: tax.id,
-                amount: sign * tax_amount,
-                name: tax.name,
-            };
-
-            taxes_vals.push(tax_vals);
+                if (tax_amount){
+                    if (tax.price_include) {
+                        total_excluded -= tax_amount;
+                        base -= tax_amount;
+                    }
+                    else {
+                        total_included += tax_amount;
+                    }
+                    if (tax.include_base_amount) {
+                        base += tax_amount;
+                    }
+                    var data = {
+                        id: tax.id,
+                        amount: tax_amount,
+                        name: tax.name,
+                    };
+                    list_taxes.push(data);
+                }
+            }
         });
         return {
-            taxes: taxes_vals,
-            total_excluded: sign * round_pr(total_excluded, currency_rounding_bak),
-            total_included: sign * round_pr(total_included, currency_rounding_bak)
+            taxes: list_taxes,
+            total_excluded: round_pr(total_excluded, currency_rounding_bak),
+            total_included: round_pr(total_included, currency_rounding_bak)
         };
     },
     get_all_prices: function(){
@@ -1817,7 +1732,6 @@ exports.Orderline = Backbone.Model.extend({
                 return t.id === el;
             }));
         });
-        product_taxes = _.map(product_taxes, this._map_tax_fiscal_position.bind(this));
 
         var all_taxes = this.compute_all(product_taxes, price_unit, this.get_quantity(), this.pos.currency.rounding);
         _(all_taxes.taxes).each(function(tax) {
diff --git a/addons/project/data/web_planner_data.xml b/addons/project/data/web_planner_data.xml
index 0b2aae71788..98ca36208ac 100644
--- a/addons/project/data/web_planner_data.xml
+++ b/addons/project/data/web_planner_data.xml
@@ -39,7 +39,7 @@
                 <t t-set="menu_categoryclasses" t-value="'fa-flag-checkered'"/>
                 <t t-call="web_planner.page">
                     <t t-set="page_title">Your Objectives</t>
-                    <t t-set="page_menutitle" t-value="'Objectives'"/>
+                    <t t-set="page_menutitle">Objectives</t>
                     <p class="text-muted">
                         It's essential to be clear about why you want to use Odoo Project and what your goals are.
                         Indeed, there are many ways to manage a project, to find the best one for you, you need to know exactly what you want to achieve. And later on, we will hopefully transform your objectives into real improvements for your company.
@@ -83,7 +83,7 @@
 
                 <t t-call="web_planner.page">
                     <t t-set="page_title">Your Activities</t>
-                    <t t-set="page_menutitle" t-value="'Activities'"/>
+                    <t t-set="page_menutitle">Activities</t>
                     <p class="text-muted">The Odoo Project app can be used to manage many activities, from the development of a new product to the daily operations of a customer support. With some creativity, it can even be used to manage your marketing communications or personal projects. But just because it can be done doesn't mean it's always a good idea: let's start by helping you understand what can be a good project.</p>
 
                     <div class="row">
@@ -116,7 +116,7 @@
 
                 <t t-call="web_planner.page">
                     <t t-set="page_title">Your Projects</t>
-                    <t t-set="page_menutitle" t-value="'Projects'"/>
+                    <t t-set="page_menutitle">Projects</t>
                     <p class="text-muted">Depending on what you need and how you want to operate, there are several ways to work with Odoo. First, decide if you want to think in terms of tasks. Then, activate the Timesheets app if you need it.</p>
                     <h4>1. Learn about Tasks and Timesheets.</h4>
                     <div class="row">
diff --git a/addons/stock/data/web_planner_data.xml b/addons/stock/data/web_planner_data.xml
index 4497d60cce2..0dd72bc5dd1 100644
--- a/addons/stock/data/web_planner_data.xml
+++ b/addons/stock/data/web_planner_data.xml
@@ -363,7 +363,7 @@
                 <t t-set="menu_categoryclasses" t-value="'fa-recycle'"/>
                 <t t-call="web_planner.page">
                     <t t-set="page_title">Reordering Rules</t>
-                    <t t-set="page_menutitle" t-value="'Reordering Rules'"/>
+                    <t t-set="page_menutitle">Reordering Rules</t>
                     <p class="text-muted">
                         A good inventory management aims to optimize stock levels: not too low (or
                         you may find yourself out of stock) and not too high (your products occupy
diff --git a/addons/stock/models/product.py b/addons/stock/models/product.py
index 204e2548223..de6f1480f1a 100644
--- a/addons/stock/models/product.py
+++ b/addons/stock/models/product.py
@@ -500,6 +500,8 @@ class ProductTemplate(models.Model):
             done_moves = self.env['stock.move'].search([('product_id', 'in', updated.mapped('product_variant_ids').ids)], limit=1)
             if done_moves:
                 raise UserError(_("You can not change the unit of measure of a product that has already been used in a done stock move. If you need to change the unit of measure, you may deactivate this product."))
+        if 'type' in vals and vals['type'] != 'product' and sum(self.mapped('nbr_reordering_rules')) != 0:
+            raise UserError(_('You still have some active reordering rules on this product. Please archive or delete them first.'))
         if any('type' in vals and vals['type'] != prod_tmpl.type for prod_tmpl in self):
             existing_move_lines = self.env['stock.move.line'].search([
                 ('product_id', 'in', self.mapped('product_variant_ids').ids),
diff --git a/addons/stock/models/stock_move.py b/addons/stock/models/stock_move.py
index aad31b90797..7ef8306d976 100644
--- a/addons/stock/models/stock_move.py
+++ b/addons/stock/models/stock_move.py
@@ -607,9 +607,13 @@ class StockMove(models.Model):
         if not self.product_id or self.product_qty < 0.0:
             self.product_qty = 0.0
         if self.product_qty < self._origin.product_qty:
-            return {'warning': _("By changing this quantity here, you accept the "
-                                 "new quantity as complete: Odoo will not "
-                                 "automatically generate a back order.")}
+            warning_mess = {
+                'title': _('Quantity decreased!'),
+                'message' : _("By changing this quantity here, you accept the "
+                              "new quantity as complete: Odoo will not "
+                              "automatically generate a back order."),
+            }
+            return {'warning': warning_mess}
 
     @api.onchange('product_id')
     def onchange_product_id(self):
diff --git a/addons/web/static/src/js/chrome/search_inputs.js b/addons/web/static/src/js/chrome/search_inputs.js
index d734bb0ebf2..d567551873f 100644
--- a/addons/web/static/src/js/chrome/search_inputs.js
+++ b/addons/web/static/src/js/chrome/search_inputs.js
@@ -349,7 +349,7 @@ var DateField = Field.extend(/** @lends instance.web.search.DateField# */{
         var t, v;
         try {
             t = (this.attrs && this.attrs.type === 'datetime') ? 'datetime' : 'date';
-            v = field_utils.parse[t](needle, {type: t});
+            v = field_utils.parse[t](needle, {type: t}, {timezone: true});
         } catch (e) {
             return $.when(null);
         }
diff --git a/addons/web/static/src/js/fields/relational_fields.js b/addons/web/static/src/js/fields/relational_fields.js
index e5a7cc3da2f..6f775e789d4 100644
--- a/addons/web/static/src/js/fields/relational_fields.js
+++ b/addons/web/static/src/js/fields/relational_fields.js
@@ -1257,9 +1257,13 @@ var FieldMany2Many = FieldX2Many.extend({
      *
      * @override
      * @private
+     * @param {OdooEvent|MouseEvent} ev this event comes either from the 'Add
+     *   record' link in the list editable renderer, or from the 'Create' button
+     *   in the kanban view
      */
-    _onAddRecord: function () {
+    _onAddRecord: function (ev) {
         var self = this;
+        ev.stopPropagation();
 
         var domain = this.record.getDomain({fieldName: this.name});
 
diff --git a/addons/web/static/src/js/services/crash_manager.js b/addons/web/static/src/js/services/crash_manager.js
index 3ce280c3aa8..9c7914eeebf 100644
--- a/addons/web/static/src/js/services/crash_manager.js
+++ b/addons/web/static/src/js/services/crash_manager.js
@@ -54,7 +54,7 @@ var CrashManager = core.Class.extend({
             new (handler)(this, error).display();
             return;
         }
-        if (error.data.name === "openerp.http.SessionExpiredException" || error.data.name === "werkzeug.exceptions.Forbidden") {
+        if (error.data.name === "odoo.http.SessionExpiredException" || error.data.name === "werkzeug.exceptions.Forbidden") {
             this.show_warning({type: _t("Odoo Session Expired"), data: {message: _t("Your Odoo session expired. Please refresh the current web page.")}});
             return;
         }
diff --git a/addons/web/static/src/js/views/basic/basic_model.js b/addons/web/static/src/js/views/basic/basic_model.js
index 4028bff322a..4bd12bf2bc3 100644
--- a/addons/web/static/src/js/views/basic/basic_model.js
+++ b/addons/web/static/src/js/views/basic/basic_model.js
@@ -3458,6 +3458,7 @@ var BasicModel = AbstractModel.extend({
                 domain: list.domain,
                 context: list.context,
                 groupBy: list.groupedBy,
+                orderBy: list.orderedBy,
                 lazy: true,
             })
             .then(function (groups) {
diff --git a/addons/web/static/tests/fields/relational_fields_tests.js b/addons/web/static/tests/fields/relational_fields_tests.js
index 2e8499b31e1..aa8fa8e4d0c 100644
--- a/addons/web/static/tests/fields/relational_fields_tests.js
+++ b/addons/web/static/tests/fields/relational_fields_tests.js
@@ -5521,6 +5521,65 @@ QUnit.module('relational_fields', {
         form.destroy();
     });
 
+    QUnit.test('many2many list in a one2many opened by a many2one', function (assert) {
+        assert.expect(1);
+
+        this.data.turtle.records[1].turtle_trululu = 2;
+        var form = createView({
+            View: FormView,
+            model: 'partner',
+            data: this.data,
+            arch: '<form string="Partners">' +
+                    '<field name="turtles">' +
+                        '<tree editable="bottom">' +
+                            '<field name="turtle_trululu"/>' +
+                        '</tree>' +
+                    '</field>' +
+                '</form>',
+            res_id: 1,
+            archs: {
+                "partner,false,form": '<form string="P">' +
+                        '<field name="timmy"/>' +
+                    '</form>',
+                "partner_type,false,list": '<tree editable="bottom">' +
+                        '<field name="display_name"/>' +
+                    '</tree>',
+                "partner_type,false,search": '<search>' +
+                    '</search>',
+            },
+            viewOptions: {
+                mode: 'edit',
+            },
+            mockRPC: function (route, args) {
+                if (route === '/web/dataset/call_kw/partner/get_formview_id') {
+                    return $.when(false);
+                }
+                if (args.method === 'write') {
+                    assert.deepEqual(args.args[1].timmy, [[6,  false, [12]]],
+                        'should properly write ids')
+                }
+                return this._super.apply(this, arguments);
+            },
+        });
+
+        // edit the first partner in the one2many partner form view
+        form.$('.o_data_row:first td.o_data_cell').click();
+        // open form view for many2one
+        form.$('.o_external_button').click();
+
+        // click on add, to add a new partner in the m2m
+        $('.modal .o_field_x2many_list_row_add a').click();
+
+        // select the partner_type 'gold' (this closes the 2nd modal)
+        $('.modal td:contains(gold)').click();
+
+        // confirm the changes in the modal
+        $('.modal .modal-footer .btn-primary').click();
+
+        form.$buttons.find('.o_form_button_save').click();
+        form.destroy();
+    });
+
     QUnit.test('one2many (who contains display_name) with tree view and without form view', function (assert) {
         assert.expect(1);
 
diff --git a/addons/web/static/tests/helpers/mock_server.js b/addons/web/static/tests/helpers/mock_server.js
index 3556fb946aa..b9d0fc50dd9 100644
--- a/addons/web/static/tests/helpers/mock_server.js
+++ b/addons/web/static/tests/helpers/mock_server.js
@@ -707,6 +707,23 @@ var MockServer = Class.extend({
 
             return res;
         });
+
+        if (kwargs.orderby) {
+            // only consider first sorting level
+            kwargs.orderby = kwargs.orderby.split(',')[0];
+            var fieldName = kwargs.orderby.split(' ')[0];
+            var order = kwargs.orderby.split(' ')[1];
+            result.sort(function (g1, g2) {
+                if (g1[fieldName] < g2[fieldName]) {
+                    return order === 'ASC' ? -1 : 1;
+                }
+                if (g1[fieldName] > g2[fieldName]) {
+                    return order === 'ASC' ? 1 : -1;
+                }
+                return 0;
+            });
+        }
+
         return result;
     },
     /**
diff --git a/addons/web/static/tests/views/list_tests.js b/addons/web/static/tests/views/list_tests.js
index 242eb2f62d6..1e4c332291f 100644
--- a/addons/web/static/tests/views/list_tests.js
+++ b/addons/web/static/tests/views/list_tests.js
@@ -637,6 +637,42 @@ QUnit.module('Views', {
         list.destroy();
     });
 
+    QUnit.test('groups can be sorted on aggregates', function (assert) {
+        assert.expect(10);
+
+        var list = createView({
+            View: ListView,
+            model: 'foo',
+            data: this.data,
+            groupBy: ['foo'],
+            arch: '<tree editable="bottom"><field name="int_field" sum="Sum"/></tree>',
+            mockRPC: function (route, args) {
+                if (args.method === 'read_group') {
+                    assert.step(args.kwargs.orderby || 'default order');
+                }
+                return this._super.apply(this, arguments);
+            },
+        });
+
+        assert.strictEqual(list.$('tbody .o_list_number').text(), '10517',
+            "initial order should be 10, 5, 17");
+        assert.strictEqual(list.$('tfoot td:nth(2)').text(), '32', "total should be 32");
+
+        list.$('.o_column_sortable').click(); // sort (int_field ASC)
+        assert.strictEqual(list.$('tfoot td:nth(2)').text(), '32', "total should still be 32");
+        assert.strictEqual(list.$('tbody .o_list_number').text(), '51017',
+            "order should be 5, 10, 17");
+
+        list.$('.o_column_sortable').click(); // sort (int_field DESC)
+        assert.strictEqual(list.$('tbody .o_list_number').text(), '17105',
+            "initial order should be 17, 10, 5");
+        assert.strictEqual(list.$('tfoot td:nth(2)').text(), '32', "total should still be 32");
+
+        assert.verifySteps(['default order', 'int_field ASC', 'int_field DESC']);
+
+        list.destroy();
+    });
+
     QUnit.test('properly apply onchange in simple case', function (assert) {
         assert.expect(2);
 
@@ -1695,7 +1731,7 @@ QUnit.module('Views', {
         // close first level group
         nbRPCs = {readGroup: 0, searchRead: 0};
         envIDs = []; // the group being closed, there is no more record in the environment
-        list.$('.o_group_header:first').click();
+        list.$('.o_group_header:nth(1)').click();
         assert.strictEqual(nbRPCs.readGroup, 0, "should have done no read_group");
         assert.strictEqual(nbRPCs.searchRead, 0, "should have done no search_read");
 
diff --git a/addons/web/static/tests/views/view_dialogs_tests.js b/addons/web/static/tests/views/view_dialogs_tests.js
index 30ab2b8274e..1d99d5b1cb7 100644
--- a/addons/web/static/tests/views/view_dialogs_tests.js
+++ b/addons/web/static/tests/views/view_dialogs_tests.js
@@ -95,6 +95,7 @@ QUnit.module('Views', {
                         domain: [["display_name","like","a"], ["display_name","ilike","piou"], ["foo","ilike","piou"]],
                         fields:["display_name","foo","bar"],
                         groupby:["bar"],
+                        orderby: '',
                         lazy: true
                     }, "should search with the complete domain (domain + search), and group by 'bar'");
                 }
diff --git a/addons/web_editor/static/src/js/widgets/widgets.js b/addons/web_editor/static/src/js/widgets/widgets.js
index 8214754cd6b..0ca3c6bef7b 100644
--- a/addons/web_editor/static/src/js/widgets/widgets.js
+++ b/addons/web_editor/static/src/js/widgets/widgets.js
@@ -1039,6 +1039,7 @@ var MediaDialog = Dialog.extend({
         this.final_data = [media, self.old_media];
         $(document.body).trigger("media-saved", this.final_data);
         $(self.old_media).trigger("save", this.final_data);
+        $(this.final_data).trigger('input');
 
         // Update editor bar after image edition (in case the image change to icon or other)
         _.defer(function () {
diff --git a/addons/website_sale/views/templates.xml b/addons/website_sale/views/templates.xml
index f417f742f52..4ea5a80a086 100644
--- a/addons/website_sale/views/templates.xml
+++ b/addons/website_sale/views/templates.xml
@@ -999,7 +999,7 @@
         <t t-if="request.params.get('code_not_available')" name="code_not_available">
             <p class="bg-warning">This promo code is not available</p>
         </t>
-        <form t-if="website_sale_order and website_sale_order.website_order_line" t-att-action="'/shop/pricelist%s' % (redirect and '?r=' + redirect or '')"
+        <form t-att-action="'/shop/pricelist%s' % (redirect and '?r=' + redirect or '')"
             method="post" class="mb32" name="coupon_code">
             <input type="hidden" name="csrf_token" t-att-value="request.csrf_token()" />
             <div class="input-group">
@@ -1499,7 +1499,7 @@
     </template>
 
     <template id="total">
-        <div id="cart_total" t-att-class="extra_class or ''" t-if="website_sale_order">
+        <div id="cart_total" t-att-class="extra_class or ''" t-if="website_sale_order and website_sale_order.website_order_line">
             <div class="row" id="order_total_untaxed">
                 <span class="col-xs-6 text-right text-muted">Subtotal:</span>
                 <span class="col-xs-6 text-right-not-xs text-left-xs text-muted">
diff --git a/doc/cla/corporate/metrum.md b/doc/cla/corporate/metrum.md
new file mode 100644
index 00000000000..b64bf351a8b
--- /dev/null
+++ b/doc/cla/corporate/metrum.md
@@ -0,0 +1,16 @@
+Belgium, 2017-11-14
+
+METRUM SA agrees to the terms of the Odoo Corporate Contributor License
+Agreement v1.0.
+
+I declare that I am authorized and able to make this agreement and sign this
+declaration.
+
+Signed,
+
+Jonathan Nemry jonathan.nemry@metrum.lu https://github.com/JonathanNEMRY
+
+List of contributors:
+
+Pascal Pelzer pascal.pelzer@metrum.lu https://github.com/PascalPelzer
+Jonathan Nemry jonathan.nemry@metrum.lu https://github.com/JonathanNEMRY
diff --git a/doc/cla/individual/grzekru.md b/doc/cla/individual/grzekru.md
new file mode 100644
index 00000000000..6dbd42dbaf6
--- /dev/null
+++ b/doc/cla/individual/grzekru.md
@@ -0,0 +1,11 @@
+Poland, 2017-09-17
+
+I hereby agree to the terms of the Odoo Individual Contributor License
+Agreement v1.0.
+
+I declare that I am authorized and able to make this agreement and sign this
+declaration.
+
+Signed,
+
+Grzegorz Krukar grzegorzgk1@gmail.com https://github.com/grzekru
\ No newline at end of file
diff --git a/doc/cla/individual/mehdi-ghezal.md b/doc/cla/individual/mehdi-ghezal.md
new file mode 100644
index 00000000000..a5083336bfd
--- /dev/null
+++ b/doc/cla/individual/mehdi-ghezal.md
@@ -0,0 +1,9 @@
+France, 2017-11-10
+
+I hereby agree to the terms of the Odoo Individual Contributor License Agreement v1.0.
+
+I declare that I am authorized and able to make this agreement and sign this declaration.
+
+Signed,
+
+Mehdi GHEZAL mehdi.ghezal@gmail.com https://github.com/mehdi-ghezal
diff --git a/doc/cla/individual/silviofdez.md b/doc/cla/individual/silviofdez.md
new file mode 100644
index 00000000000..b7e52cc183c
--- /dev/null
+++ b/doc/cla/individual/silviofdez.md
@@ -0,0 +1,11 @@
+Spain, 2017-10-24
+
+I hereby agree to the terms of the Odoo Individual Contributor License
+Agreement v1.0.
+
+I declare that I am authorized and able to make this agreement and sign this
+declaration.
+
+Signed,
+
+Silvio Fernandez silviofernandezmarin@gmail.com https://github.com/silviofdez
\ No newline at end of file
diff --git a/doc/reference/javascript.rst b/doc/reference/javascript.rst
index b7696a2e983..b2d08bb255b 100644
--- a/doc/reference/javascript.rst
+++ b/doc/reference/javascript.rst
@@ -10,3 +10,1403 @@ Javascript
 
 .. automodule:: *
     :members:
+
+=======
+Widgets
+=======
+
+.. class:: Widget
+
+    Exported in ``web.Widget``, the base class for all visual components.
+    It corresponds to an MVC view, and provides a number of service to
+    simplify handling of a section of a page:
+
+    * Handles parent/child relationships between widgets
+    * Provides extensive lifecycle management with safety features (e.g.
+      automatically destroying children widgets during the destruction of a
+      parent)
+    * Automatic rendering with :ref:`qweb <reference/qweb>`
+    * Backbone-compatible shortcuts
+
+DOM Root
+--------
+
+A :class:`~Widget` is responsible for a section of the page
+materialized by the DOM root of the widget.
+
+A widget's DOM root is available via two attributes:
+
+.. attribute:: Widget.el
+
+    raw DOM element set as root to the widget
+
+.. attribute:: Widget.$el
+
+    jQuery wrapper around :attr:`~Widget.el`
+
+There are two main ways to define and generate this DOM root:
+
+.. attribute:: Widget.template
+
+    Should be set to the name of a :ref:`QWeb template <reference/qweb>`.
+    If set, the template will be rendered after the widget has been
+    initialized but before it has been started. The root element generated by
+    the template will be set as the DOM root of the widget.
+
+.. attribute:: Widget.tagName
+
+    Used if the widget has no template defined. Defaults to ``div``,
+    will be used as the tag name to create the DOM element to set as
+    the widget's DOM root. It is possible to further customize this
+    generated DOM root with the following attributes:
+
+    .. attribute:: Widget.id
+
+        Used to generate an ``id`` attribute on the generated DOM
+        root.
+
+    .. attribute:: Widget.className
+
+        Used to generate a ``class`` attribute on the generated DOM root.
+
+    .. attribute:: Widget.attributes
+
+        Mapping (object literal) of attribute names to attribute
+        values. Each of these k:v pairs will be set as a DOM attribute
+        on the generated DOM root.
+
+    None of these is used in case a template is specified on the widget.
+
+The DOM root can also be defined programmatically by overridding
+
+.. function:: Widget.renderElement
+
+    Renders the widget's DOM root and sets it. The default
+    implementation will render a set template or generate an element
+    as described above, and will call
+    :func:`~Widget.setElement` on the result.
+
+    Any override to :func:`~Widget.renderElement` which
+    does not call its ``_super`` **must** call
+    :func:`~Widget.setElement` with whatever it
+    generated or the widget's behavior is undefined.
+
+    .. note::
+
+        The default :func:`~Widget.renderElement` can
+        be called repeatedly, it will *replace* the previous DOM root
+        (using ``replaceWith``). However, this requires that the
+        widget correctly sets and unsets its events (and children
+        widgets). Generally, :func:`~Widget.renderElement` should
+        not be called repeatedly unless the widget advertizes this feature.
+
+Using a widget
+''''''''''''''
+
+A widget's lifecycle has 3 main phases:
+
+* creation and initialization of the widget instance
+
+  .. function:: Widget.init(parent)
+
+       initialization method of widgets, synchronous, can be overridden to
+       take more parameters from the widget's creator/parent
+
+       :param parent: the new widget's parent, used to handle automatic
+                      destruction and event propagation. Can be ``null`` for
+                      the widget to have no parent.
+       :type parent: :class:`~Widget`
+
+* DOM injection and startup, this is done by calling one of:
+
+  .. function:: Widget.appendTo(element)
+
+    Renders the widget and inserts it as the last child of the target, uses
+    `.appendTo()`_
+
+  .. function:: Widget.prependTo(element)
+
+    Renders the widget and inserts it as the first child of the target, uses
+    `.prependTo()`_
+
+  .. function:: Widget.insertAfter(element)
+
+    Renders the widget and inserts it as the preceding sibling of the target,
+    uses `.insertAfter()`_
+
+  .. function:: Widget.insertBefore(element)
+
+    Renders the widget and inserts it as the following sibling of the target,
+    uses `.insertBefore()`_
+
+  All of these methods accept whatever the corresponding jQuery method accepts
+  (CSS selectors, DOM nodes or jQuery objects). They all return a deferred_
+  and are charged with three tasks:
+
+  * rendering the widget's root element via
+    :func:`~Widget.renderElement`
+  * inserting the widget's root element in the DOM using whichever jQuery
+    method they match
+  * starting the widget, and returning the result of starting it
+
+    .. function:: Widget.start()
+
+        asynchronous startup of the widget once it's been injected in the DOM,
+        generally used to perform asynchronous RPC calls to fetch whatever
+        remote data is necessary for the widget to do its work.
+
+        Must return a deferred_ to indicate when its work is done.
+
+        A widget is *not guaranteed* to work correctly until its
+        :func:`~Widget.start` method has finished executing. The
+        widget's parent/creator must wait for a widget to be fully started
+        before interacting with it
+
+        :returns: deferred_ object
+
+* widget destruction and cleanup
+
+  .. function:: Widget.destroy()
+
+    destroys the widget's children, unbinds its events and removes its root
+    from the DOM. Automatically called when the widget's parent is destroyed,
+    must be called explicitly if the widget has no parents or if it is
+    removed but its parent remains.
+
+    A widget being destroyed is automatically unlinked from its parent.
+
+Related to widget destruction is an important utility method:
+
+.. function:: Widget.alive(deferred[, reject=false])
+
+    A significant issue with RPC and destruction is that an RPC call may take
+    a long time to execute and return while a widget is being destroyed or
+    after it has been destroyed, trying to execute its operations on a widget
+    in a broken/invalid state.
+
+    This is a frequent source of errors or strange behaviors.
+
+    :func:`~Widget.alive` can be used to wrap an RPC call,
+    ensuring that whatever operations should be executed when the call ends
+    are only executed if the widget is still alive::
+
+        this.alive(this.model.query().all()).then(function (records) {
+            // would break if executed after the widget is destroyed, wrapping
+            // rpc in alive() prevents execution
+            _.each(records, function (record) {
+                self.$el.append(self.format(record));
+            });
+        });
+
+    :param deferred: a deferred_ object to wrap
+    :param reject: by default, if the RPC call returns after the widget has
+                   been destroyed the returned deferred_ is left in limbo
+                   (neither resolved nor rejected). If ``reject`` is set to
+                   ``true``, the deferred_ will be rejected instead.
+    :returns: deferred_ object
+
+.. function:: Widget.isDestroyed()
+
+    :returns: ``true`` if the widget is being or has been destroyed, ``false``
+              otherwise
+
+Accessing DOM content
+'''''''''''''''''''''
+
+Because a widget is only responsible for the content below its DOM root, there
+ is a shortcut for selecting sub-sections of a widget's DOM:
+
+.. function:: Widget.$(selector)
+
+    Applies the CSS selector specified as parameter to the widget's
+    DOM root::
+
+        this.$(selector);
+
+    is functionally identical to::
+
+        this.$el.find(selector);
+
+    :param String selector: CSS selector
+    :returns: jQuery object
+
+    .. note:: this helper method is similar to ``Backbone.View.$``
+
+Resetting the DOM root
+''''''''''''''''''''''
+
+.. function:: Widget.setElement(element)
+
+    Re-sets the widget's DOM root to the provided element, also
+    handles re-setting the various aliases of the DOM root as well as
+    unsetting and re-setting delegated events.
+
+    :param Element element: a DOM element or jQuery object to set as
+                            the widget's DOM root
+
+    .. note:: should be mostly compatible with `Backbone's
+              setElement`_
+
+DOM events handling
+-------------------
+
+A widget will generally need to respond to user action within its
+section of the page. This entails binding events to DOM elements.
+
+To this end, :class:`~Widget` provides a shortcut:
+
+.. attribute:: Widget.events
+
+    Events are a mapping of an event selector (an event name and an optional
+    CSS selector separated by a space) to a callback. The callback can
+    be the name of a widget's method or a function object. In either case, the
+    ``this`` will be set to the widget::
+
+        events: {
+            'click p.oe_some_class a': 'some_method',
+            'change input': function (e) {
+                e.stopPropagation();
+            }
+        },
+
+    The selector is used for jQuery's `event delegation`_, the
+    callback will only be triggered for descendants of the DOM root
+    matching the selector\ [#eventsdelegation]_. If the selector is left out
+    (only an event name is specified), the event will be set directly on the
+    widget's DOM root.
+
+.. function:: Widget.delegateEvents
+
+    This method is in charge of binding :attr:`~Widget.events` to the
+    DOM. It is automatically called after setting the widget's DOM root.
+
+    It can be overridden to set up more complex events than the
+    :attr:`~Widget.events` map allows, but the parent should always be
+    called (or :attr:`~Widget.events` won't be handled correctly).
+
+.. function:: Widget.undelegateEvents
+
+    This method is in charge of unbinding :attr:`~Widget.events` from
+    the DOM root when the widget is destroyed or the DOM root is reset, in
+    order to avoid leaving "phantom" events.
+
+    It should be overridden to un-set any event set in an override of
+    :func:`~Widget.delegateEvents`.
+
+.. note:: this behavior should be compatible with `Backbone's
+          delegateEvents`_, apart from not accepting any argument.
+
+Subclassing Widget
+------------------
+
+:class:`~Widget` is subclassed in the standard manner (via the
+:func:`~Class.extend` method), and provides a number of
+abstract properties and concrete methods (which you may or may not want to
+override). Creating a subclass looks like this::
+
+    var MyWidget = Widget.extend({
+        // QWeb template to use when rendering the object
+        template: "MyQWebTemplate",
+        events: {
+            // events binding example
+            'click .my-button': 'handle_click',
+        },
+
+        init: function(parent) {
+            this._super(parent);
+            // insert code to execute before rendering, for object
+            // initialization
+        },
+        start: function() {
+            var sup = this._super();
+            // post-rendering initialization code, at this point
+
+            // allows multiplexing deferred objects
+            return $.when(
+                // propagate asynchronous signal from parent class
+                sup,
+                // return own's asynchronous signal
+                this.rpc(/* … */))
+        }
+    });
+
+The new class can then be used in the following manner::
+
+    // Create the instance
+    var my_widget = new MyWidget(this);
+    // Render and insert into DOM
+    my_widget.appendTo(".some-div");
+
+After these two lines have executed (and any promise returned by
+:func:`~Widget.appendTo` has been resolved if needed), the widget is
+ready to be used.
+
+.. note:: the insertion methods will start the widget themselves, and will
+          return the result of :func:`~Widget.start()`.
+
+          If for some reason you do not want to call these methods, you will
+          have to first call :func:`~Widget.render()` on the
+          widget, then insert it into your DOM and start it.
+
+If the widget is not needed anymore (because it's transient), simply terminate
+it::
+
+    my_widget.destroy();
+
+will unbind all DOM events, remove the widget's content from the DOM and
+destroy all widget data.
+
+Development Guidelines
+----------------------
+
+* Identifiers (``id`` attribute) should be avoided. In generic applications
+  and modules, ``id`` limits the re-usability of components and tends to make
+  code more brittle. Most of the time, they can be replaced with nothing,
+  classes or keeping a reference to a DOM node or jQuery element.
+
+  If an ``id`` is absolutely necessary (because a third-party library requires
+  one), the id should be partially generated using ``_.uniqueId()`` e.g.::
+
+      this.id = _.uniqueId('my-widget-')
+* Avoid predictable/common CSS class names. Class names such as "content" or
+  "navigation" might match the desired meaning/semantics, but it is likely an
+  other developer will have the same need, creating a naming conflict and
+  unintended behavior. Generic class names should be prefixed with e.g. the
+  name of the component they belong to (creating "informal" namespaces, much
+  as in C or Objective-C).
+* Global selectors should be avoided. Because a component may be used several
+  times in a single page (an example in Odoo is dashboards), queries should be
+  restricted to a given component's scope. Unfiltered selections such as
+  ``$(selector)`` or ``document.querySelectorAll(selector)`` will generally
+  lead to unintended or incorrect behavior.  Odoo Web's
+  :class:`~Widget` has an attribute providing its DOM root
+  (:attr:`~Widget.$el`), and a shortcut to select nodes directly
+  (:func:`~Widget.$`).
+* More generally, never assume your components own or controls anything beyond
+  its own personal :attr:`~Widget.$el`
+* html templating/rendering should use QWeb unless absolutely trivial.
+* All interactive components (components displaying information to the screen
+  or intercepting DOM events) must inherit from :class:`~Widget`
+  and correctly implement and use its API and life cycle.
+
+.. _.appendTo():
+    http://api.jquery.com/appendTo/
+
+.. _.prependTo():
+    http://api.jquery.com/prependTo/
+
+.. _.insertAfter():
+    http://api.jquery.com/insertAfter/
+
+.. _.insertBefore():
+    http://api.jquery.com/insertBefore/
+
+.. _event delegation:
+    http://api.jquery.com/delegate/
+
+.. _Backbone's setElement:
+    http://backbonejs.org/#View-setElement
+
+.. _Backbone's delegateEvents:
+    http://backbonejs.org/#View-delegateEvents
+
+.. _deferred: http://api.jquery.com/category/deferred-object/
+
+RPC
+===
+
+To display and interact with data, calls to the Odoo server are necessary.
+This is performed using :abbr:`RPC <Remote Procedure Call>`.
+
+Odoo Web provides two primary APIs to handle this: a low-level
+JSON-RPC based API communicating with the Python section of Odoo
+Web (and of your module, if you have a Python part) and a high-level
+API above that allowing your code to talk directly to high-level Odoo models.
+
+All networking APIs are :ref:`asynchronous <reference/async>`. As a result,
+all of them will return Deferred_ objects (whether they resolve those with
+values or not). Understanding how those work before before moving on is
+probably necessary.
+
+High-level API: calling into Odoo models
+-------------------------------------------
+
+Access to Odoo object methods (made available through XML-RPC from the server)
+is done via :class:`Model`. It maps onto the Odoo server objects via two primary
+methods, :func:`~Model.call` (exported in ``web.Model``) and :func:`~Model.query`
+(exported in ``web.DataModel``, only available in the backend client).
+
+:func:`~Model.call` is a direct mapping to the corresponding method of
+the Odoo server object. Its usage is similar to that of the Odoo Model API,
+with three differences:
+
+* The interface is :ref:`asynchronous <reference/async>`, so instead of
+  returning results directly RPC method calls will return
+  Deferred_ instances, which will themselves resolve to the
+  result of the matching RPC call.
+
+* Because ECMAScript 3/Javascript 1.5 doesnt feature any equivalent to
+  ``__getattr__`` or ``method_missing``, there needs to be an explicit
+  method to dispatch RPC methods.
+
+* No notion of pooler, the model proxy is instantiated where needed,
+  not fetched from an other (somewhat global) object::
+
+    var Users = new Model('res.users');
+
+    Users.call('change_password', ['oldpassword', 'newpassword'],
+                      {context: some_context}).then(function (result) {
+        // do something with change_password result
+    });
+
+:func:`~Model.query` is a shortcut for a builder-style
+interface to searches (``search`` + ``read`` in Odoo RPC terms). It
+returns a :class:`~odoo.web.Query` object which is immutable but
+allows building new :class:`~odoo.web.Query` instances from the
+first one, adding new properties or modifiying the parent object's::
+
+    Users.query(['name', 'login', 'user_email', 'signature'])
+         .filter([['active', '=', true], ['company_id', '=', main_company]])
+         .limit(15)
+         .all().then(function (users) {
+        // do work with users records
+    });
+
+The query is only actually performed when calling one of the query
+serialization methods, :func:`~odoo.web.Query.all` and
+:func:`~odoo.web.Query.first`. These methods will perform a new
+RPC call every time they are called.
+
+For that reason, it's actually possible to keep "intermediate" queries
+around and use them differently/add new specifications on them.
+
+.. class:: Model(name)
+
+    .. attribute:: Model.name
+
+        name of the model this object is bound to
+
+    .. function:: Model.call(method[, args][, kwargs])
+
+         Calls the ``method`` method of the current model, with the
+         provided positional and keyword arguments.
+
+         :param String method: method to call over rpc on the
+                               :attr:`~Model.name`
+         :param Array<> args: positional arguments to pass to the
+                              method, optional
+         :param Object<> kwargs: keyword arguments to pass to the
+                                 method, optional
+         :rtype: Deferred<>
+
+    .. function:: Model.query(fields)
+
+         :param Array<String> fields: list of fields to fetch during
+                                      the search
+         :returns: a :class:`~odoo.web.Query` object
+                   representing the search to perform
+
+.. class:: odoo.web.Query(fields)
+
+    The first set of methods is the "fetching" methods. They perform
+    RPC queries using the internal data of the object they're called
+    on.
+
+    .. function:: odoo.web.Query.all()
+
+        Fetches the result of the current :class:`~odoo.web.Query` object's
+        search.
+
+        :rtype: Deferred<Array<>>
+
+    .. function:: odoo.web.Query.first()
+
+       Fetches the **first** result of the current
+       :class:`~odoo.web.Query`, or ``null`` if the current
+       :class:`~odoo.web.Query` does have any result.
+
+       :rtype: Deferred<Object | null>
+
+    .. function:: odoo.web.Query.count()
+
+       Fetches the number of records the current
+       :class:`~odoo.web.Query` would retrieve.
+
+       :rtype: Deferred<Number>
+
+    .. function:: odoo.web.Query.group_by(grouping...)
+
+       Fetches the groups for the query, using the first specified
+       grouping parameter
+
+       :param Array<String> grouping: Lists the levels of grouping
+                                      asked of the server. Grouping
+                                      can actually be an array or
+                                      varargs.
+       :rtype: Deferred<Array<odoo.web.QueryGroup>> | null
+
+    The second set of methods is the "mutator" methods, they create a
+    **new** :class:`~odoo.web.Query` object with the relevant
+    (internal) attribute either augmented or replaced.
+
+    .. function:: odoo.web.Query.context(ctx)
+
+       Adds the provided ``ctx`` to the query, on top of any existing
+       context
+
+    .. function:: odoo.web.Query.filter(domain)
+
+       Adds the provided domain to the query, this domain is
+       ``AND``-ed to the existing query domain.
+
+    .. function:: opeenrp.web.Query.offset(offset)
+
+       Sets the provided offset on the query. The new offset
+       *replaces* the old one.
+
+    .. function:: odoo.web.Query.limit(limit)
+
+       Sets the provided limit on the query. The new limit *replaces*
+       the old one.
+
+    .. function:: odoo.web.Query.order_by(fields…)
+
+       Overrides the model's natural order with the provided field
+       specifications. Behaves much like Django's :py:meth:`QuerySet.order_by
+       <django.db.models.query.QuerySet.order_by>`:
+
+       * Takes 1..n field names, in order of most to least importance
+         (the first field is the first sorting key). Fields are
+         provided as strings.
+
+       * A field specifies an ascending order, unless it is prefixed
+         with the minus sign "``-``" in which case the field is used
+         in the descending order
+
+       Divergences from Django's sorting include a lack of random sort
+       (``?`` field) and the inability to "drill down" into relations
+       for sorting.
+
+Aggregation (grouping)
+''''''''''''''''''''''
+
+Odoo has powerful grouping capacities, but they are kind-of strange
+in that they're recursive, and level n+1 relies on data provided
+directly by the grouping at level n. As a result, while
+:py:meth:`odoo.models.Model.read_group` works it's not a very intuitive
+API.
+
+Odoo Web eschews direct calls to :py:meth:`~odoo.models.Model.read_group`
+in favor of calling a method of :class:`~odoo.web.Query`, :py:meth:`much
+in the way it is done in SQLAlchemy <sqlalchemy.orm.query.Query.group_by>`
+[#terminal]_::
+
+    some_query.group_by(['field1', 'field2']).then(function (groups) {
+        // do things with the fetched groups
+    });
+
+This method is asynchronous when provided with 1..n fields (to group
+on) as argument, but it can also be called without any field (empty
+fields collection or nothing at all). In this case, instead of
+returning a Deferred object it will return ``null``.
+
+When grouping criterion come from a third-party and may or may not
+list fields (e.g. could be an empty list), this provides two ways to
+test the presence of actual subgroups (versus the need to perform a
+regular query for records):
+
+* A check on ``group_by``'s result and two completely separate code
+  paths::
+
+      var groups;
+      if (groups = some_query.group_by(gby)) {
+          groups.then(function (gs) {
+              // groups
+          });
+      }
+      // no groups
+
+* Or a more coherent code path using :func:`when`'s ability to
+  coerce values into deferreds::
+
+      $.when(some_query.group_by(gby)).then(function (groups) {
+          if (!groups) {
+              // No grouping
+          } else {
+              // grouping, even if there are no groups (groups
+              // itself could be an empty array)
+          }
+      });
+
+The result of a (successful) :func:`~odoo.web.Query.group_by` is
+an array of :class:`~odoo.web.QueryGroup`:
+
+.. class:: odoo.web.QueryGroup
+
+    .. function:: odoo.web.QueryGroup.get(key)
+
+        returns the group's attribute ``key``. Known attributes are:
+
+        ``grouped_on``
+            which grouping field resulted from this group
+        ``value``
+            ``grouped_on``'s value for this group
+        ``length``
+            the number of records in the group
+        ``aggregates``
+            a {field: value} mapping of aggregations for the group
+
+    .. function:: odoo.web.QueryGroup.query([fields...])
+
+        equivalent to :func:`Model.query` but pre-filtered to
+        only include the records within this group. Returns a
+        :class:`~odoo.web.Query` which can be further manipulated as
+        usual.
+
+    .. function:: odoo.web.QueryGroup.subgroups()
+
+        returns a deferred to an array of :class:`~odoo.web.QueryGroup`
+        below this one
+
+Low-level API: RPC calls to Python side
+---------------------------------------
+
+While the previous section is great for calling core OpenERP code
+(models code), it does not work if you want to call the Python side of
+Odoo Web.
+
+For this, a lower-level API exists on on
+:class:`~Session` objects (the class is exported in ``web.Session``, but
+an instance isusually available through ``web.session``): the ``rpc`` method.
+
+This method simply takes an absolute path (the absolute URL of the JSON
+:ref:`route <reference/http/routing>` to call) and a mapping of attributes to
+values (passed as keyword arguments to the Python method). This function
+fetches the return value of the Python methods, converted to JSON.
+
+For instance, to call the ``resequence`` of the
+:class:`~web.controllers.main.DataSet` controller::
+
+    session.rpc('/web/dataset/resequence', {
+        model: some_model,
+        ids: array_of_ids,
+        offset: 42
+    }).then(function (result) {
+        // resequence didn't error out
+    }, function () {
+        // an error occured during during call
+    });
+
+.. _reference/javascript/client:
+
+Web Client
+==========
+
+Javascript module system overview
+---------------------------------
+
+A new module system (inspired from requirejs) has now been deployed.
+It has many advantages over the Odoo version 8 system.
+
+* loading order: dependencies are guaranteed to be loaded first, even if
+  files are not loaded in the correct order in the bundle files.
+* easier to split a file into smaller logical units.
+* no global variables: easier to reason.
+* it is possible to examine every dependencies and dependants.  This
+  makes refactoring much simpler, and less risky.
+
+It has also some disadvantages:
+
+* files are required to use the module system if they want to interact 
+  with odoo, since the various objects are only available in the module
+  system, and not in global variables
+* circular dependencies are not supported.  It makes sense, but it means
+  that one needs to be careful.
+
+This is obviously a very large change and will require everyone to
+adopt new habits.  For example, the variable odoo does not exist
+anymore.  The new way of doing things is to import explicitely the module 
+you need, and declaring explicitely the objects you export.  Here is a
+simple example::
+
+    odoo.define('addon_name.service', function (require) {
+        var utils = require('web.utils');
+        var Model = require('web.Model');
+
+        // do things with utils and Model
+        var something_useful = 15;
+        return  {
+            something_useful: something_useful,
+        };
+    });
+
+This snippet shows a module named ``addon_name.service``.  It is defined
+with the ``odoo.define`` function.  ``odoo.define`` takes a name and a
+function for arguments:
+
+* The name is the concatenation of the name of the addon it is defined in
+  and a name describing its purpose.
+* The function is the place where the javascript module is actually
+  defined.  It takes a function ``require`` as first argument, and
+  returns something (or not, depending if it needs to export something).
+  The ``require`` function is used to get a handle on the dependencies.
+  In this case, it gives a handle on two javascript modules from the 
+  ``web`` addon, namely ``web.utils`` and ``web.Model``.
+
+The idea is that you define what you need to import (by using the
+``require`` function) and declare what you export (by returning
+something).  The web client will then make sure that your code is loaded
+properly.
+
+Modules are contained in a file, but a file can define several modules 
+(however, it is better to keep them in separate files).
+
+Each module can return a deferred. In that case, the module is marked as loaded
+only when the deferred is resolved, and its value is equal to the resolved value.
+The module can be rejected (unloaded). This will be logged in the console as info.
+
+* ``Missing dependencies``:
+  These modules do not appear in the page. It is possible that the JavaScript 
+  file is not in the page or that the module name is wrong
+* ``Failed modules``:
+  A javascript error is detected
+* ``Rejected modules``:
+  The module returns a rejected deferred. It (and its dependent modules) is not 
+  loaded.
+* ``Rejected linked modules``:
+  Modules who depend on a rejected module
+* ``Non loaded modules``:
+  Modules who depend on a missing or a failed module
+
+
+Web client structure
+--------------------
+
+The web client files have been refactored into smaller and simpler files.
+Here is a description of the current file structure:
+
+* the ``framework/`` folder contains all basic low level modules.  The
+  modules here are supposed to be generic.  Some of them are:
+
+  * ``web.ajax`` implements rpc calls
+  * ``web.core`` is a generic modules.  It exports various useful
+    objects and functions, such as ``qweb``, ``_t`` or the main bus.
+  * ``web.Widget`` contains the widget class
+  * ``web.Model`` is an abstraction over ``web.ajax`` to make
+    calls to the server model methods
+  * ``web.session`` is the former ``odoo.session``
+  * ``web.utils`` for useful code snippets
+  * ``web.time`` for every time-related generic functions
+* the ``views/`` folder contains all view definitions
+* ``widgets/`` is for standalone widgets
+
+The ``js/`` folder also contains some important files:
+
+* ``action_manager.js`` is the ActionManager class
+* ``boot.js`` is the file actually implementing the module system
+* ``menu.js`` is the definition of the top menu
+* ``web_client.js`` is for the root widget WebClient
+* ``view_manager.js`` contains the ViewManager
+
+The two other files are ``tour.js`` for the tours and ``compatibility.js``.
+The latter file is a compatibility layer bridging the old system to the
+new module system.  This is where every module names are exported to the
+global variable ``odoo``.  In theory, our addons should work without
+ever using the variable ``odoo``, and the compatibility module can be
+disabled safely.
+
+Javascript conventions
+----------------------
+
+Here are some basic conventions for the javascript code:
+
+* declare all your dependencies at the top of the module.  Also, they
+  should be sorted alphabetically by module name.  This makes it
+  easier to understand your module.
+* declare all exports at the end.
+* add the ``use strict`` statement at the beginning of every module
+* always name your module properly: ``addon_name.description``.
+* use capital letters for classes (for example, ``ActionManager`` is
+  defined in the module ``web.ActionManager``), and lowercase for
+  everything else (for example, ``ajax`` is defined in ``web.ajax``).
+* declare one module per file
+
+
+
+
+
+Testing in Odoo Web Client
+==========================
+
+Javascript Unit Testing
+-----------------------
+
+Odoo Web includes means to unit-test both the core code of
+Odoo Web and your own javascript modules. On the javascript side,
+unit-testing is based on QUnit_ with a number of helpers and
+extensions for better integration with Odoo.
+
+To see what the runner looks like, find (or start) an Odoo server
+with the web client enabled, and navigate to ``/web/tests``
+This will show the runner selector, which lists all modules with javascript
+unit tests, and allows starting any of them (or all javascript tests in all
+modules at once).
+
+.. image:: ./images/runner.png
+    :align: center
+
+Clicking any runner button will launch the corresponding tests in the
+bundled QUnit_ runner:
+
+.. image:: ./images/tests.png
+    :align: center
+
+Writing a test case
+-------------------
+
+The first step is to list the test file(s). This is done through the
+``test`` key of the Odoo manifest, by adding javascript files to it:
+
+.. code-block:: python
+
+    {
+        'name': "Demonstration of web/javascript tests",
+        'category': 'Hidden',
+        'depends': ['web'],
+        'test': ['static/tests/demo.js'],
+    }
+
+and to create the corresponding test file(s)
+
+.. note::
+
+    Test files which do not exist will be ignored, if all test files
+    of a module are ignored (can not be found), the test runner will
+    consider that the module has no javascript tests.
+
+After that, refreshing the runner selector will display the new module
+and allow running all of its (0 so far) tests:
+
+.. image:: ./images/runner2.png
+    :align: center
+
+The next step is to create a test case::
+
+    odoo.testing.section('basic section', function (test) {
+        test('my first test', function () {
+            ok(false, "this test has run");
+        });
+    });
+
+All testing helpers and structures live in the ``odoo.testing``
+module. Odoo tests live in a :func:`~odoo.testing.section`,
+which is itself part of a module. The first argument to a section is
+the name of the section, the second one is the section body.
+
+:func:`test <odoo.testing.case>`, provided by the
+:func:`~odoo.testing.section` to the callback, is used to
+register a given test case which will be run whenever the test runner
+actually does its job. Odoo Web test case use standard `QUnit
+assertions`_ within them.
+
+Launching the test runner at this point will run the test and display
+the corresponding assertion message, with red colors indicating the
+test failed:
+
+.. image:: ./images/tests2.png
+    :align: center
+
+Fixing the test (by replacing ``false`` to ``true`` in the assertion)
+will make it pass:
+
+.. image:: ./images/tests3.png
+    :align: center
+
+Assertions
+----------
+
+As noted above, Odoo Web's tests use `qunit assertions`_. They are
+available globally (so they can just be called without references to
+anything). The following list is available:
+
+.. function:: ok(state[, message])
+
+    checks that ``state`` is truthy (in the javascript sense)
+
+.. function:: strictEqual(actual, expected[, message])
+
+    checks that the actual (produced by a method being tested) and
+    expected values are identical (roughly equivalent to ``ok(actual
+    === expected, message)``)
+
+.. function:: notStrictEqual(actual, expected[, message])
+
+    checks that the actual and expected values are *not* identical
+    (roughly equivalent to ``ok(actual !== expected, message)``)
+
+.. function:: deepEqual(actual, expected[, message])
+
+    deep comparison between actual and expected: recurse into
+    containers (objects and arrays) to ensure that they have the same
+    keys/number of elements, and the values match.
+
+.. function:: notDeepEqual(actual, expected[, message])
+
+    inverse operation to :func:`deepEqual`
+
+.. function:: throws(block[, expected][, message])
+
+    checks that, when called, the ``block`` throws an
+    error. Optionally validates that error against ``expected``.
+
+    :param Function block:
+    :param expected: if a regexp, checks that the thrown error's
+                     message matches the regular expression. If an
+                     error type, checks that the thrown error is of
+                     that type.
+    :type expected: Error | RegExp
+
+.. function:: equal(actual, expected[, message])
+
+    checks that ``actual`` and ``expected`` are loosely equal, using
+    the ``==`` operator and its coercion rules.
+
+.. function:: notEqual(actual, expected[, message])
+
+    inverse operation to :func:`equal`
+
+Getting an Odoo instance
+------------------------
+
+The Odoo instance is the base through which most Odoo Web
+modules behaviors (functions, objects, …) are accessed. As a result,
+the test framework automatically builds one, and loads the module
+being tested and all of its dependencies inside it. This new instance
+is provided as the first positional parameter to your test
+cases. Let's observe by adding javascript code (not test code) to the
+test module:
+
+.. code-block:: python
+
+    {
+        'name': "Demonstration of web/javascript tests",
+        'category': 'Hidden',
+        'depends': ['web'],
+        'js': ['static/src/js/demo.js'],
+        'test': ['static/tests/demo.js'],
+    }
+
+::
+
+    // src/js/demo.js
+    odoo.web_tests_demo = function (instance) {
+        instance.web_tests_demo = {
+            value_true: true,
+            SomeType: instance.web.Class.extend({
+                init: function (value) {
+                    this.value = value;
+                }
+            })
+        };
+    };
+
+and then adding a new test case, which simply checks that the
+``instance`` contains all the expected stuff we created in the
+module::
+
+    // test/demo.js
+    test('module content', function (instance) {
+        ok(instance.web_tests_demo.value_true, "should have a true value");
+        var type_instance = new instance.web_tests_demo.SomeType(42);
+        strictEqual(type_instance.value, 42, "should have provided value");
+    });
+
+DOM Scratchpad
+--------------
+
+As in the wider client, arbitrarily accessing document content is
+strongly discouraged during tests. But DOM access is still needed to
+e.g. fully initialize :class:`widgets <~odoo.Widget>` before
+testing them.
+
+Thus, a test case gets a DOM scratchpad as its second positional
+parameter, in a jQuery instance. That scratchpad is fully cleaned up
+before each test, and as long as it doesn't do anything outside the
+scratchpad your code can do whatever it wants::
+
+    // test/demo.js
+    test('DOM content', function (instance, $scratchpad) {
+        $scratchpad.html('<div><span class="foo bar">ok</span></div>');
+        ok($scratchpad.find('span').hasClass('foo'),
+           "should have provided class");
+    });
+    test('clean scratchpad', function (instance, $scratchpad) {
+        ok(!$scratchpad.children().length, "should have no content");
+        ok(!$scratchpad.text(), "should have no text");
+    });
+
+.. note::
+
+    The top-level element of the scratchpad is not cleaned up, test
+    cases can add text or DOM children but shoud not alter
+    ``$scratchpad`` itself.
+
+Loading templates
+-----------------
+
+To avoid the corresponding processing costs, by default templates are
+not loaded into QWeb. If you need to render e.g. widgets making use of
+QWeb templates, you can request their loading through the
+:attr:`~TestOptions.templates` option to the :func:`test case
+function <odoo.testing.case>`.
+
+This will automatically load all relevant templates in the instance's
+qweb before running the test case:
+
+.. code-block:: python
+
+    {
+        'name': "Demonstration of web/javascript tests",
+        'category': 'Hidden',
+        'depends': ['web'],
+        'js': ['static/src/js/demo.js'],
+        'test': ['static/tests/demo.js'],
+        'qweb': ['static/src/xml/demo.xml'],
+    }
+
+.. code-block:: xml
+
+    <!-- src/xml/demo.xml -->
+    <templates id="template" xml:space="preserve">
+        <t t-name="DemoTemplate">
+            <t t-foreach="5" t-as="value">
+                <p><t t-esc="value"/></p>
+            </t>
+        </t>
+    </templates>
+
+::
+
+    // test/demo.js
+    test('templates', {templates: true}, function (instance) {
+        var s = instance.web.qweb.render('DemoTemplate');
+        var texts = $(s).find('p').map(function () {
+            return $(this).text();
+        }).get();
+
+        deepEqual(texts, ['0', '1', '2', '3', '4']);
+    });
+
+Asynchronous cases
+------------------
+
+The test case examples so far are all synchronous, they execute from
+the first to the last line and once the last line has executed the
+test is done. But the web client is full of :ref:`asynchronous code
+<reference/async>`, and thus test cases need to be async-aware.
+
+This is done by returning a :class:`deferred <Deferred>` from the
+case callback::
+
+    // test/demo.js
+    test('asynchronous', {
+        asserts: 1
+    }, function () {
+        var d = $.Deferred();
+        setTimeout(function () {
+            ok(true);
+            d.resolve();
+        }, 100);
+        return d;
+    });
+
+This example also uses the :class:`options parameter <TestOptions>`
+to specify the number of assertions the case should expect, if less or
+more assertions are specified the case will count as failed.
+
+Asynchronous test cases *must* specify the number of assertions they
+will run. This allows more easily catching situations where e.g. the
+test architecture was not warned about asynchronous operations.
+
+.. note::
+
+    Asynchronous test cases also have a 2 seconds timeout: if the test
+    does not finish within 2 seconds, it will be considered
+    failed. This pretty much always means the test will not
+    resolve. This timeout *only* applies to the test itself, not to
+    the setup and teardown processes.
+
+.. note::
+
+    If the returned deferred is rejected, the test will be failed
+    unless :attr:`~TestOptions.fail_on_rejection` is set to
+    ``false``.
+
+RPC
+---
+
+An important subset of asynchronous test cases is test cases which
+need to perform (and chain, to an extent) RPC calls.
+
+.. note::
+
+    Because they are a subset of asynchronous cases, RPC cases must
+    also provide a valid :attr:`assertions count
+    <TestOptions.asserts>`.
+
+To enable mock RPC, set the :attr:`rpc option <TestOptions.rpc>` to
+``mock``. This will add a third parameter to the test case callback:
+
+.. function:: mock(rpc_spec, handler)
+
+    Can be used in two different ways depending on the shape of the
+    first parameter:
+
+    * If it matches the pattern ``model:method`` (if it contains a
+      colon, essentially) the call will set up the mocking of an RPC
+      call straight to the Odoo server (through XMLRPC) as
+      performed via e.g. :func:`odoo.web.Model.call`.
+
+      In that case, ``handler`` should be a function taking two
+      arguments ``args`` and ``kwargs``, matching the corresponding
+      arguments on the server side and should simply return the value
+      as if it were returned by the Python XMLRPC handler::
+
+          test('XML-RPC', {rpc: 'mock', asserts: 3}, function (instance, $s, mock) {
+              // set up mocking
+              mock('people.famous:name_search', function (args, kwargs) {
+                  strictEqual(kwargs.name, 'bob');
+                  return [
+                      [1, "Microsoft Bob"],
+                      [2, "Bob the Builder"],
+                      [3, "Silent Bob"]
+                  ];
+              });
+
+              // actual test code
+              return new instance.web.Model('people.famous')
+                  .call('name_search', {name: 'bob'}).then(function (result) {
+                      strictEqual(result.length, 3, "shoud return 3 people");
+                      strictEqual(result[0][1], "Microsoft Bob",
+                          "the most famous bob should be Microsoft Bob");
+                  });
+          });
+
+    * Otherwise, if it matches an absolute path (e.g. ``/a/b/c``) it
+      will mock a JSON-RPC call to a web client controller, such as
+      ``/web/webclient/translations``. In that case, the handler takes
+      a single ``params`` argument holding all of the parameters
+      provided over JSON-RPC.
+
+      As previously, the handler should simply return the result value
+      as if returned by the original JSON-RPC handler::
+
+          test('JSON-RPC', {rpc: 'mock', asserts: 3, templates: true}, function (instance, $s, mock) {
+              var fetched_dbs = false, fetched_langs = false;
+              mock('/web/database/get_list', function () {
+                  fetched_dbs = true;
+                  return ['foo', 'bar', 'baz'];
+              });
+              mock('/web/session/get_lang_list', function () {
+                  fetched_langs = true;
+                  return [['vo_IS', 'Hopelandic / Vonlenska']];
+              });
+
+              // widget needs that or it blows up
+              instance.webclient = {toggle_bars: odoo.testing.noop};
+              var dbm = new instance.web.DatabaseManager({});
+              return dbm.appendTo($s).then(function () {
+                  ok(fetched_dbs, "should have fetched databases");
+                  ok(fetched_langs, "should have fetched languages");
+                  deepEqual(dbm.db_list, ['foo', 'bar', 'baz']);
+              });
+          });
+
+.. note::
+
+    Mock handlers can contain assertions, these assertions should be
+    part of the assertions count (and if multiple calls are made to a
+    handler containing assertions, it multiplies the effective number
+    of assertions).
+
+Testing API
+-----------
+
+.. function:: odoo.testing.section(name[, options], body)
+
+    A test section, serves as shared namespace for related tests (for
+    constants or values to only set up once). The ``body`` function
+    should contain the tests themselves.
+
+    Note that the order in which tests are run is essentially
+    undefined, do *not* rely on it.
+
+    :param String name:
+    :param TestOptions options:
+    :param body:
+    :type body: Function<:func:`~odoo.testing.case`, void>
+
+.. function:: odoo.testing.case(name[, options], callback)
+
+    Registers a test case callback in the test runner, the callback
+    will only be run once the runner is started (or maybe not at all,
+    if the test is filtered out).
+
+    :param String name:
+    :param TestOptions options:
+    :param callback:
+    :type callback: Function<instance, $, Function<String, Function, void>>
+
+.. class:: TestOptions
+
+    the various options which can be passed to
+    :func:`~odoo.testing.section` or
+    :func:`~odoo.testing.case`. Except for
+    :attr:`~TestOptions.setup` and
+    :attr:`~TestOptions.teardown`, an option on
+    :func:`~odoo.testing.case` will overwrite the corresponding
+    option on :func:`~odoo.testing.section` so
+    e.g. :attr:`~TestOptions.rpc` can be set for a
+    :func:`~odoo.testing.section` and then differently set for
+    some :func:`~odoo.testing.case` of that
+    :func:`~odoo.testing.section`
+
+    .. attribute:: TestOptions.asserts
+
+        An integer, the number of assertions which should run during a
+        normal execution of the test. Mandatory for asynchronous tests.
+
+    .. attribute:: TestOptions.setup
+
+        Test case setup, run right before each test case. A section's
+        :func:`~TestOptions.setup` is run before the case's own, if
+        both are specified.
+
+    .. attribute:: TestOptions.teardown
+
+        Test case teardown, a case's :func:`~TestOptions.teardown`
+        is run before the corresponding section if both are present.
+
+    .. attribute:: TestOptions.fail_on_rejection
+
+        If the test is asynchronous and its resulting promise is
+        rejected, fail the test. Defaults to ``true``, set to
+        ``false`` to not fail the test in case of rejection::
+
+            // test/demo.js
+            test('unfail rejection', {
+                asserts: 1,
+                fail_on_rejection: false
+            }, function () {
+                var d = $.Deferred();
+                setTimeout(function () {
+                    ok(true);
+                    d.reject();
+                }, 100);
+                return d;
+            });
+
+    .. attribute:: TestOptions.rpc
+
+        RPC method to use during tests, one of ``"mock"`` or
+        ``"rpc"``. Any other value will disable RPC for the test (if
+        they were enabled by the suite for instance).
+
+    .. attribute:: TestOptions.templates
+
+        Whether the current module (and its dependencies)'s templates
+        should be loaded into QWeb before starting the test. A
+        boolean, ``false`` by default.
+
+The test runner can also use two global configuration values set
+directly on the ``window`` object:
+
+* ``oe_all_dependencies`` is an ``Array`` of all modules with a web
+  component, ordered by dependency (for a module ``A`` with
+  dependencies ``A'``, any module of ``A'`` must come before ``A`` in
+  the array)
+
+Running through Python
+----------------------
+
+The web client includes the means to run these tests on the
+command-line (or in a CI system), but while actually running it is
+pretty simple the setup of the pre-requisite parts has some
+complexities.
+
+#. Install PhantomJS_. It is a headless
+   browser which allows automating running and testing web
+   pages. QUnitSuite_ uses it to actually run the qunit_ test suite.
+
+   The PhantomJS_ website provides pre-built binaries for some
+   platforms, and your OS's package management probably provides it as
+   well.
+
+   If you're building PhantomJS_ from source, I recommend preparing
+   for some knitting time as it's not exactly fast (it needs to
+   compile both `Qt <http://qt-project.org/>`_ and `Webkit
+   <http://www.webkit.org/>`_, both being pretty big projects).
+
+   .. note::
+
+       Because PhantomJS_ is webkit-based, it will not be able to test
+       if Firefox, Opera or Internet Explorer can correctly run the
+       test suite (and it is only an approximation for Safari and
+       Chrome). It is therefore recommended to *also* run the test
+       suites in actual browsers once in a while.
+
+   .. note::
+
+       The version of PhantomJS_ this was build through is 1.7,
+       previous versions *should* work but are not actually supported
+       (and tend to just segfault when something goes wrong in
+       PhantomJS_ itself so they're a pain to debug).
+
+#. Install a new database with all relevant modules (all modules with
+   a web component at least), then restart the server
+
+   .. note::
+
+       For some tests, a source database needs to be duplicated. This
+       operation requires that there be no connection to the database
+       being duplicated, but Odoo doesn't currently break
+       existing/outstanding connections, so restarting the server is
+       the simplest way to ensure everything is in the right state.
+
+#. Launch ``oe run-tests -d $DATABASE -mweb`` with the correct
+   addons-path specified (and replacing ``$DATABASE`` by the source
+   database you created above)
+
+   .. note::
+
+       If you leave out ``-mweb``, the runner will attempt to run all
+       the tests in all the modules, which may or may not work.
+
+If everything went correctly, you should now see a list of tests with
+(hopefully) ``ok`` next to their names, closing with a report of the
+number of tests run and the time it took:
+
+.. literalinclude:: test-report.txt
+    :language: text
+
+Congratulation, you have just performed a successful "offline" run of
+the OpenERP Web test suite.
+
+.. note::
+
+    Note that this runs all the Python tests for the ``web`` module,
+    but all the web tests for all of Odoo. This can be surprising.
+
+.. _qunit: http://qunitjs.com/
+
+.. _qunit assertions: http://api.qunitjs.com/category/assert/
+
+.. _QUnitSuite: http://pypi.python.org/pypi/QUnitSuite/
+
+.. _PhantomJS: http://phantomjs.org/
+
+.. [#eventsdelegation] not all DOM events are compatible with events delegation
+
+.. [#terminal]
+    with a small twist: :py:meth:`sqlalchemy.orm.query.Query.group_by` is not
+    terminal, it returns a query which can still be altered.
diff --git a/odoo/addons/test_impex/tests/test_export.py b/odoo/addons/test_impex/tests/test_export.py
index d5460d0dd5c..9c7311319e8 100644
--- a/odoo/addons/test_impex/tests/test_export.py
+++ b/odoo/addons/test_impex/tests/test_export.py
@@ -305,12 +305,13 @@ class test_m2o(CreatorCase):
             [[False]])
 
     def test_basic(self):
-        """ Exported value is empty
+        """ Exported value is the name_get of the related object
         """
         record = self.env['export.integer'].create({'value': 42})
+        name = dict(record.name_get())[record.id]
         self.assertEqual(
             self.export(record.id),
-            [['']])
+            [[name]])
 
     def test_path(self):
         """ Can recursively export fields of m2o via path
@@ -352,13 +353,14 @@ class test_o2m(CreatorCase):
     def test_single(self):
         self.assertEqual(
             self.export([(0, False, {'value': 42})]),
-            [['']])
+            # name_get result
+            [[u'export.one2many.child:42']])
 
     def test_single_subfield(self):
         self.assertEqual(
             self.export([(0, False, {'value': 42})],
                         fields=['value', 'value/value']),
-            [['', u'42']])
+            [[u'export.one2many.child:42', u'42']])
 
     def test_integrate_one_in_parent(self):
         self.assertEqual(
@@ -380,13 +382,9 @@ class test_o2m(CreatorCase):
     def test_multiple_records_name(self):
         self.assertEqual(
             self.export(self.commands, fields=['const', 'value']),
-            [
-                [u'4', ''],
-                ['', ''],
-                ['', ''],
-                ['', ''],
-                ['', ''],
-            ])
+            [[
+                u'4', u','.join(self.names)
+            ]])
 
     def test_multiple_records_id(self):
         export = self.export(self.commands, fields=['const', 'value/.id'])
@@ -404,18 +402,14 @@ class test_o2m(CreatorCase):
     def test_multiple_records_with_name_before(self):
         self.assertEqual(
             self.export(self.commands, fields=['const', 'value', 'value/value']),
-            [
-                [u'4', '', u'4'],
-                ['', '', u'42'],
-                ['', '', u'36'],
-                ['', '', u'4'],
-                ['', '', u'13'],
-            ])
+            [[ # exports sub-fields of very first o2m
+                u'4', u','.join(self.names), u'4'
+            ]])
 
     def test_multiple_records_with_name_after(self):
         self.assertEqual(
             self.export(self.commands, fields=['const', 'value/value', 'value']),
-            [
+            [ # completely ignores name_get request
                 [u'4', u'4', ''],
                 ['', u'42', ''],
                 ['', u'36', ''],
@@ -466,16 +460,16 @@ class test_o2m_multiple(CreatorCase):
     def test_single_per_side(self):
         self.assertEqual(
             self.export(child1=False, child2=[(0, False, {'value': 42})]),
-            [[False, '']])
+            [[False, u'export.one2many.child.2:42']])
 
         self.assertEqual(
             self.export(child1=[(0, False, {'value': 43})], child2=False),
-            [['', False]])
+            [[u'export.one2many.child.1:43', False]])
 
         self.assertEqual(
             self.export(child1=[(0, False, {'value': 43})],
                         child2=[(0, False, {'value': 42})]),
-            [['', '']])
+            [[u'export.one2many.child.1:43', u'export.one2many.child.2:42']])
 
     def test_single_integrate_subfield(self):
         fields = ['const', 'child1/value', 'child2/value']
@@ -562,13 +556,14 @@ class test_m2m(CreatorCase):
     def test_single(self):
         self.assertEqual(
             self.export([(0, False, {'value': 42})]),
-            [['']])
+            # name_get result
+            [[u'export.many2many.other:42']])
 
     def test_single_subfield(self):
         self.assertEqual(
             self.export([(0, False, {'value': 42})],
                         fields=['value', 'value/value']),
-            [['', u'42']])
+            [[u'export.many2many.other:42', u'42']])
 
     def test_integrate_one_in_parent(self):
         self.assertEqual(
@@ -590,13 +585,10 @@ class test_m2m(CreatorCase):
     def test_multiple_records_name(self):
         self.assertEqual(
             self.export(self.commands, fields=['const', 'value']),
-            [
-                [u'4', ''],
-                ['', ''],
-                ['', ''],
-                ['', ''],
-                ['', ''],
-            ])
+            [[ # FIXME: hardcoded comma, import uses config.csv_internal_sep
+               # resolution: remove configurable csv_internal_sep
+                u'4', u','.join(self.names)
+            ]])
 
     # essentially same as o2m, so boring
 
diff --git a/odoo/models.py b/odoo/models.py
index 7ddd58451a4..dea095cd4c9 100644
--- a/odoo/models.py
+++ b/odoo/models.py
@@ -697,8 +697,14 @@ class BaseModel(MetaModel('DummyModel', (object,), {'_register': False})):
                             for j, val in enumerate(lines2[0]):
                                 if val or isinstance(val, bool):
                                     current[j] = val
-                            # append the other lines at the end
-                            lines += lines2[1:]
+                            # check value of current field
+                            if not current[i] and not isinstance(current[i], bool):
+                                # assign xml_ids, and forget about remaining lines
+                                xml_ids = [item[1] for item in value.name_get()]
+                                current[i] = ','.join(xml_ids)
+                            else:
+                                # append the other lines at the end
+                                lines += lines2[1:]
                         else:
                             current[i] = False
 
diff --git a/odoo/service/server.py b/odoo/service/server.py
index 70141644b81..835ecd3b27a 100644
--- a/odoo/service/server.py
+++ b/odoo/service/server.py
@@ -364,15 +364,15 @@ class GeventServer(CommonServer):
         import gevent
         from gevent.wsgi import WSGIServer
 
-        # Set process memory limit as an extra safeguard
-        _, hard = resource.getrlimit(resource.RLIMIT_AS)
-        resource.setrlimit(resource.RLIMIT_AS, (config['limit_memory_hard'], hard))
 
         if os.name == 'posix':
+            # Set process memory limit as an extra safeguard
+            _, hard = resource.getrlimit(resource.RLIMIT_AS)
+            resource.setrlimit(resource.RLIMIT_AS, (config['limit_memory_hard'], hard))
             signal.signal(signal.SIGQUIT, dumpstacks)
             signal.signal(signal.SIGUSR1, log_ormcache_stats)
-
-        gevent.spawn(self.watchdog)
+            gevent.spawn(self.watchdog)
+        
         self.httpd = WSGIServer((self.interface, self.port), self.app)
         _logger.info('Evented Service (longpolling) running on %s:%s', self.interface, self.port)
         try:
diff --git a/odoo/tools/misc.py b/odoo/tools/misc.py
index 49f8024c5ed..64875c07543 100644
--- a/odoo/tools/misc.py
+++ b/odoo/tools/misc.py
@@ -1077,7 +1077,7 @@ def formatLang(env, value, digits=None, grouping=True, monetary=False, dp=False,
     if isinstance(value, pycompat.string_types) and not value:
         return ''
 
-    lang = env.user.company_id.partner_id.lang or 'en_US'
+    lang = env.context.get('lang') or env.user.company_id.partner_id.lang or 'en_US'
     lang_objs = env['res.lang'].search([('code', '=', lang)])
     if not lang_objs:
         lang_objs = env['res.lang'].search([], limit=1)
diff --git a/requirements.txt b/requirements.txt
index f003d714858..16eda9e10ec 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -16,7 +16,7 @@ ofxparse==0.16
 passlib==1.6.5
 Pillow==3.4.1
 psutil==4.3.1
-psycopg2==2.7.1
+psycopg2==2.7.3
 pydot==1.2.3
 pyldap==2.4.28
 pyparsing==2.1.10