[IMP] website,*: support multiple websites

This implements support to administer multiple websites. Although the
core functionality already existed, managing multiple websites was
fairly technical.

In the interest of database updates and migration this attempts to
keep duplicated data to a minimum. To do this the usual generic
records are rendered unless some website-specific record exists that
replaces it. Copy-on-write (COW) is used to create these
website-specific records. Through this mechanism creating a
website-specific record is delayed until necessary. A COW mechanism
has been implemented on 4 models: ir.ui.view, website.page,
website.menu and ir.attachment. These COW mechanisms are activated
when editing data through the website (aka frontend). These frontend
edits (e.g. with web_editor) will be website-specific, possibly
creating a website-specific record when necessary. When editing data
in the backend nothing special will happen, even when editing a
generic record. Note that because of this mechanism also facilitates
the ability to create new, uncustomized websites because the generic
data is kept.

Support is provided for a website to have any theme. Themes are fairly
complex to handle. Standalone themes can depend on other standalone
themes (e.g. theme_beauty depends on theme_loftspace) and themes
usually modify some data of the themes they depend on. Because a theme
can be installed on multiple websites, using website_id m2o fields
does not work well. It would require duplicate data, making updates
and migration harder. Because of this, data for themes (ir.ui.view and
ir.attachment specifically) have a theme_id m2o. website has a
theme_ids m2m that identifies all theme modules currently installed on
it. Through these fields we figure out what to render. A theme is only
fully uninstalled when it's no longer active on any website. The
advantage of this approach is that upgrading or migrating theme data
is no different from the single-website case.

The website.published.mixin class was modified to handle multiple
websites. A wizard was added in the backend to easily manage this for
multiple website.

Although not used anywhere in this commit, a 'website_id' variable has
been added in the evaluation context of ir.rule. It allows to easily
make any model multi-website aware, all that's needed is a custom
website_id m2o field on a model and a custom record rule.

4 files changed, 331 insertions, 0 deletions

diff --git a/addons/website/tests/__init__.py b/addons/website/tests/__init__.py
index a4415acbb7d..1c57eeab793 100644
--- a/addons/website/tests/__init__.py
+++ b/addons/website/tests/__init__.py
@@ -6,3 +6,5 @@ from . import test_qweb
 from . import test_crawl
 from . import test_ui
 from . import test_views
+from . import test_menu
+from . import test_page
diff --git a/addons/website/tests/test_menu.py b/addons/website/tests/test_menu.py
new file mode 100644
index 00000000000..e01b020bef8
--- /dev/null
+++ b/addons/website/tests/test_menu.py
@@ -0,0 +1,110 @@
+# coding: utf-8
+from odoo.tests import common
+
+
+class TestMenu(common.TransactionCase):
+    def setUp(self):
+        super(TestMenu, self).setUp()
+        Menu = self.env['website.menu']
+
+        self.menu_root = Menu.create({
+            'name': 'Root',
+        })
+
+        self.menu_child = Menu.create({
+            'name': 'Child',
+            'parent_id': self.menu_root.id,
+        })
+
+        self.menu_leaf1 = Menu.create({
+            'name': 'Leaf 1',
+            'parent_id': self.menu_child.id,
+        })
+
+        self.menu_leaf2 = Menu.create({
+            'name': 'Leaf 2',
+            'parent_id': self.menu_root.id,
+        })
+
+        # create an extra website so we have 3 in total
+        self.website_test = self.env['website'].create({'domain': 'test'})
+
+    def test_cow_leaf(self):
+        Menu = self.env['website.menu']
+
+        # backend write, no COW
+        total_menu_items = Menu.search_count([])
+        self.menu_leaf1.write({'name': 'Leaf 1 modified'})
+        self.assertEqual(total_menu_items, Menu.search_count([]))
+
+        # write through website 1
+        self.menu_leaf1.with_context(website_id=1).write({'name': 'Leaf 1 Website 1'})
+        self.assertEqual(self.menu_leaf1.name, 'Leaf 1 modified')
+        self.assertEqual(total_menu_items + 1, Menu.search_count([]))
+        new_menu = Menu.search([('name', '=', 'Leaf 1 Website 1')])
+        self.assertEqual(new_menu.website_id.id, 1)
+
+    def test_cow_root(self):
+        Menu = self.env['website.menu']
+
+        # backend write, no COW
+        total_menu_items = Menu.search_count([])
+        self.menu_root.write({'name': 'Root 1 modified'})
+        self.assertEqual(total_menu_items, Menu.search_count([]))
+
+        # write through website 1
+        self.menu_root.with_context(website_id=1).write({'name': 'Root Website 1'})
+        self.assertEqual(self.menu_root.name, 'Root 1 modified')
+        self.assertEqual(total_menu_items + 4, Menu.search_count([]))
+
+        # verify parent/child structure
+        website_specific_leaf2 = Menu.search([('name', '=', 'Leaf 2'), ('website_id', '=', 1)])
+        website_specific_leaf1 = Menu.search([('name', '=', 'Leaf 1'), ('website_id', '=', 1)])
+        website_specific_child = Menu.search([('name', '=', 'Child'), ('website_id', '=', 1)])
+        website_specific_root = Menu.search([('name', '=', 'Root Website 1'), ('website_id', '=', 1)])
+        self.assertEqual(website_specific_leaf2.parent_id.id, website_specific_root.id)
+        self.assertEqual(website_specific_leaf1.parent_id.id, website_specific_child.id)
+        self.assertEqual(website_specific_child.parent_id.id, website_specific_root.id)
+
+    def test_cou_leaf(self):
+        Menu = self.env['website.menu']
+
+        # backend unlink, no COU
+        self.menu_leaf1.unlink()
+        self.assertEqual(len(Menu.search([('name', '=', 'Leaf 1')])), 0)
+
+        total_menu_items = Menu.search_count([])
+        self.menu_leaf2.with_context(website_id=1).unlink()
+
+        website_specific_menus = Menu.search([('name', '=', 'Leaf 2')])
+        self.assertEqual(len(website_specific_menus), 2)
+        self.assertEqual(set(website_specific_menus.mapped('website_id').ids), set([2, self.website_test.id]))
+
+        # exactly 2 website-specific menu items were created and one was deleted
+        self.assertEqual(total_menu_items + 1, Menu.search_count([]))
+
+    def test_cou_root_backend(self):
+        Menu = self.env['website.menu']
+        total_menu_items = Menu.search_count([])
+        self.menu_root.unlink()
+
+        # should have deleted root and all children
+        self.assertEqual(total_menu_items - 4, Menu.search_count([]))
+
+    def test_cou_root_frontend(self):
+        Menu = self.env['website.menu']
+        total_menu_items = Menu.search_count([])
+        self.menu_root.with_context(website_id=1).unlink()
+
+        # should have removed 4 generic menus and created root and all children for 2 remaining websites
+        self.assertEqual(Menu.search_count([('name', '=', 'Root'), ('website_id', '=', 2)]), 1)
+        self.assertEqual(Menu.search_count([('name', '=', 'Child'), ('website_id', '=', 2)]), 1)
+        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 1'), ('website_id', '=', 2)]), 1)
+        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 2'), ('website_id', '=', 2)]), 1)
+
+        self.assertEqual(Menu.search_count([('name', '=', 'Root'), ('website_id', '=', self.website_test.id)]), 1)
+        self.assertEqual(Menu.search_count([('name', '=', 'Child'), ('website_id', '=', self.website_test.id)]), 1)
+        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 1'), ('website_id', '=', self.website_test.id)]), 1)
+        self.assertEqual(Menu.search_count([('name', '=', 'Leaf 2'), ('website_id', '=', self.website_test.id)]), 1)
+
+        self.assertEqual(total_menu_items + 4, Menu.search_count([]))
diff --git a/addons/website/tests/test_page.py b/addons/website/tests/test_page.py
new file mode 100644
index 00000000000..76bfa52e51d
--- /dev/null
+++ b/addons/website/tests/test_page.py
@@ -0,0 +1,136 @@
+# coding: utf-8
+from odoo.tests import common
+
+
+class TestPage(common.TransactionCase):
+    def setUp(self):
+        super(TestPage, self).setUp()
+        View = self.env['ir.ui.view']
+        Page = self.env['website.page']
+        Menu = self.env['website.menu']
+
+        self.base_view = View.create({
+            'name': 'Base',
+            'type': 'qweb',
+            'arch': '<div>content</div>',
+            'key': 'test.base_view',
+        })
+
+        self.extension_view = View.create({
+            'name': 'Extension',
+            'mode': 'extension',
+            'inherit_id': self.base_view.id,
+            'arch': '<div position="inside">, extended content</div>',
+        })
+
+        self.page_1 = Page.create({
+            'view_id': self.base_view.id,
+            'url': '/page_1',
+        })
+
+        self.page_1_menu = Menu.create({
+            'name': 'Page 1 menu',
+            'page_id': self.page_1.id,
+        })
+
+    def test_cow_page(self):
+        Menu = self.env['website.menu']
+        Page = self.env['website.page']
+        View = self.env['ir.ui.view']
+
+        # backend write, no COW
+        total_pages = Page.search_count([])
+        total_menus = Menu.search_count([])
+        total_views = View.search_count([])
+        self.page_1.write({'arch': '<div>modified base content</div>'})
+        self.assertEqual(total_pages, Page.search_count([]))
+        self.assertEqual(total_menus, Menu.search_count([]))
+        self.assertEqual(total_views, View.search_count([]))
+
+        # edit through frontend
+        self.page_1.with_context(website_id=1).write({'arch': '<div>website 1 content</div>'})
+
+        # should have created website-specific copies for:
+        # - page
+        # - menu
+        # - view x2 (base view + extension view)
+        # and shouldn't have touched original records
+        self.assertEqual(total_pages + 1, Page.search_count([]))
+        self.assertEqual(total_menus + 1, Menu.search_count([]))
+        self.assertEqual(total_views + 2, View.search_count([]))
+
+        self.assertEqual(self.page_1.arch, '<div>modified base content</div>')
+        self.assertEqual(bool(self.page_1.website_id), False)
+        self.assertEqual(bool(self.page_1_menu.website_id), False)
+
+        new_page = Page.search([('url', '=', '/page_1'), ('id', '!=', self.page_1.id)])
+        self.assertEqual(new_page.website_id.id, 1)
+        self.assertEqual(new_page.view_id.inherit_children_ids[0].website_id.id, 1)
+        self.assertEqual(new_page.arch, '<div>website 1 content</div>')
+
+        new_menu = new_page.menu_ids[0]
+        self.assertEqual(new_menu.website_id.id, 1)
+
+    def test_cow_extension_view(self):
+        ''' test cow on extension view itself (like web_editor would do in the frontend) '''
+        Menu = self.env['website.menu']
+        Page = self.env['website.page']
+        View = self.env['ir.ui.view']
+
+        # nothing special should happen when editing through the backend
+        total_pages = Page.search_count([])
+        total_menus = Menu.search_count([])
+        total_views = View.search_count([])
+        self.extension_view.write({'arch': '<div>modified extension content</div>'})
+        self.assertEqual(self.extension_view.arch, '<div>modified extension content</div>')
+        self.assertEqual(total_pages, Page.search_count([]))
+        self.assertEqual(total_menus, Menu.search_count([]))
+        self.assertEqual(total_views, View.search_count([]))
+
+        # When editing through the frontend a website-specific copy
+        # for the extension view should be created. When rendering the
+        # original website.page on website 1 it will look differently
+        # due to this new extension view.
+        self.extension_view.with_context(website_id=1).write({'arch': '<div>website 1 content</div>'})
+        self.assertEqual(total_pages, Page.search_count([]))
+        self.assertEqual(total_menus, Menu.search_count([]))
+        self.assertEqual(total_views + 1, View.search_count([]))
+
+        self.assertEqual(self.extension_view.arch, '<div>modified extension content</div>')
+        self.assertEqual(bool(self.page_1.website_id), False)
+        self.assertEqual(bool(self.page_1_menu.website_id), False)
+
+        new_view = View.search([('name', '=', 'Extension'), ('website_id', '=', 1)])
+        self.assertEqual(new_view.arch, '<div>website 1 content</div>')
+        self.assertEqual(new_view.website_id.id, 1)
+
+    def test_cou_page_backend(self):
+        Menu = self.env['website.menu']
+        Page = self.env['website.page']
+        View = self.env['ir.ui.view']
+
+        # currently the view unlink of website.page can't handle views with inherited views
+        self.extension_view.unlink()
+
+        self.page_1.unlink()
+        self.assertEqual(Menu.search_count([('name', '=', 'Page 1 menu')]), 0)
+        self.assertEqual(Page.search_count([('url', '=', '/page_1')]), 0)
+        self.assertEqual(View.search_count([('name', 'in', ('Base', 'Extension'))]), 0)
+
+    def test_cou_page_frontend(self):
+        Menu = self.env['website.menu']
+        Page = self.env['website.page']
+        View = self.env['ir.ui.view']
+
+        # currently the view unlink of website.page can't handle views with inherited views
+        self.extension_view.unlink()
+
+        self.page_1.with_context(website_id=1).unlink()
+
+        self.assertEqual(bool(self.base_view.exists()), False)
+        self.assertEqual(bool(self.page_1.exists()), False)
+        self.assertEqual(bool(self.page_1_menu.exists()), False)
+
+        self.assertEqual(Menu.search([('name', '=', 'Page 1 menu')]).website_id.id, 2)
+        self.assertEqual(Page.search([('url', '=', '/page_1')]).website_id.id, 2)
+        self.assertEqual(View.search([('name', 'in', ('Base', 'Extension'))]).mapped('website_id').id, 2)
diff --git a/addons/website/tests/test_views.py b/addons/website/tests/test_views.py
index 7293eae4c56..10c2f3bcbf8 100644
--- a/addons/website/tests/test_views.py
+++ b/addons/website/tests/test_views.py
@@ -258,3 +258,86 @@ class TestViewSaving(common.TransactionCase):
                     ))
             )
         )
+
+    def test_cow_leaf(self):
+        View = self.env['ir.ui.view']
+
+        base_view = View.create({
+            'name': 'Base',
+            'type': 'qweb',
+            'arch': '<div>base content</div>',
+        }).with_context(load_all_views=True)
+
+        inherit_view = View.create({
+            'name': 'Extension',
+            'mode': 'extension',
+            'inherit_id': base_view.id,
+            'arch': '<div position="replace"><div>extended content</div></div>',
+        })
+
+        # edit on backend, regular write
+        inherit_view.write({'arch': '<div position="replace"><div>modified content</div></div>'})
+        self.assertEqual(View.search_count([('name', '=', 'Base')]), 1)
+        self.assertEqual(View.search_count([('name', '=', 'Extension')]), 1)
+
+        arch = base_view.read_combined(['arch'])['arch']
+        self.assertEqual(arch, '<div>modified content</div>')
+
+        # edit on frontend, copy just the leaf
+        inherit_view.with_context(website_id=1).write({'arch': '<div position="replace"><div>website 1 content</div></div>'})
+        inherit_views = View.search([('name', '=', 'Extension')])
+        self.assertEqual(View.search_count([('name', '=', 'Base')]), 1)
+        self.assertEqual(len(inherit_views), 2)
+        self.assertEqual(len(inherit_views.filtered(lambda v: v.website_id.id == 1)), 1)
+
+        # read in backend should be unaffected
+        arch = base_view.read_combined(['arch'])['arch']
+        self.assertEqual(arch, '<div>modified content</div>')
+        # read on website should reflect change
+        arch = base_view.with_context(website_id=1).read_combined(['arch'])['arch']
+        self.assertEqual(arch, '<div>website 1 content</div>')
+
+        # website-specific inactive view should take preference over active generic one when viewing the website
+        # this is necessary to make customize_show=True templates work correctly
+        inherit_views.filtered(lambda v: v.website_id.id == 1).write({'active': False})
+        arch = base_view.with_context(website_id=1).read_combined(['arch'])['arch']
+        self.assertEqual(arch, '<div>base content</div>')
+
+    def test_cow_root(self):
+        View = self.env['ir.ui.view']
+
+        base_view = View.create({
+            'name': 'Base',
+            'type': 'qweb',
+            'arch': '<div>content</div>',
+        })
+
+        View.create({
+            'name': 'Extension',
+            'mode': 'extension',
+            'inherit_id': base_view.id,
+            'arch': '<div position="inside">, extended content</div>',
+        })
+
+        # edit on backend, regular write
+        base_view.write({'arch': '<div>modified base content</div>'})
+        self.assertEqual(View.search_count([('name', '=', 'Base')]), 1)
+        self.assertEqual(View.search_count([('name', '=', 'Extension')]), 1)
+
+        # edit on frontend, copy the entire tree
+        base_view.with_context(website_id=1).write({'arch': '<div>website 1 content</div>'})
+
+        generic_base_view = View.search([('name', '=', 'Base'), ('website_id', '=', False)])
+        website_specific_base_view = View.search([('name', '=', 'Base'), ('website_id', '=', 1)])
+        self.assertEqual(len(generic_base_view), 1)
+        self.assertEqual(len(website_specific_base_view), 1)
+
+        inherit_views = View.search([('name', '=', 'Extension')])
+        self.assertEqual(len(inherit_views), 2)
+        self.assertEqual(len(inherit_views.filtered(lambda v: v.website_id.id == 1)), 1)
+
+        arch = generic_base_view.with_context(load_all_views=True).read_combined(['arch'])['arch']
+        self.assertEqual(arch, '<div>modified base content, extended content</div>')
+
+        arch = website_specific_base_view.with_context(load_all_views=True, website_id=1).read_combined(['arch'])['arch']
+        self.assertEqual(arch, '<div>website 1 content, extended content</div>')