Fix the cache when we call the application from different URL

geoportal/c2cgeoportal_geoportal/views/entry.py

@@ -783,8 +783,9 @@ def _is_internal_wms(layer):
             isinstance(layer, main.LayerV1) and layer.layer_type == "internal WMS"
 
     @cache_region.cache_on_arguments()
-    def _get_ogc_servers(self, group, depth):
+    def _get_ogc_servers(self, host_url, group, depth):
         """ Recurse on all children to get unique identifier for each child. """
+
         ogc_servers = set()
 
         # escape loop
@@ -795,7 +796,7 @@ def _get_ogc_servers(self, group, depth):
         # recurse on children
         if isinstance(group, main.LayerGroup) and len(group.children) > 0:
             for tree_item in group.children:
-                ogc_servers.update(self._get_ogc_servers(tree_item, depth + 1))
+                ogc_servers.update(self._get_ogc_servers(host_url, tree_item, depth + 1))
 
         if isinstance(group, main.LayerWMS):
             ogc_servers.add(group.ogc_server.name)
@@ -806,7 +807,7 @@ def _get_ogc_servers(self, group, depth):
         return ogc_servers
 
     def _group(
-        self, path, group, layers, depth=1, min_levels=1,
+        self, host_url, path, group, layers, depth=1, min_levels=1,
         catalogue=True, role_id=None, version=1, mixed=True, time=None, dim=None,
         wms_layers=None, layers_name=None, **kwargs
     ):
@@ -830,7 +831,7 @@ def _group(
         ogc_servers = None
         org_depth = depth
         if depth == 1:
-            ogc_servers = list(self._get_ogc_servers(group, 1))
+            ogc_servers = list(self._get_ogc_servers(host_url, group, 1))
             # check if mixed content
             mixed = len(ogc_servers) != 1 or ogc_servers[0] is False
             if not mixed:
@@ -842,7 +843,7 @@ def _group(
                 if isinstance(group, main.Theme) or catalogue or \
                         group.is_internal_wms == tree_item.is_internal_wms:
                     gp, gp_errors = self._group(
-                        u"{0!s}/{1!s}".format(path, tree_item.name),
+                        host_url, u"{0!s}/{1!s}".format(path, tree_item.name),
                         tree_item, layers, depth=depth + 1, min_levels=min_levels,
                         catalogue=catalogue, role_id=role_id, version=version, mixed=mixed,
                         time=time, dim=dim, wms_layers=wms_layers, layers_name=layers_name, **kwargs
@@ -922,7 +923,8 @@ def _group(
             return None, errors
 
     @cache_region.cache_on_arguments()
-    def _layers(self, role_id, version, interface):
+    def _layers(self, host_url, role_id, version, interface):
+        del host_url  # Only for cache
         query = self._create_layer_query(role_id, version, interface=interface)
         return [name for (name,) in query.all()]
 
@@ -960,7 +962,7 @@ def _load_tree_items(self):
 
     @cache_region.cache_on_arguments()
     def _themes(
-        self, role_id, interface="desktop", filter_themes=True, version=1,
+        self, host_url, role_id, interface="desktop", filter_themes=True, version=1,
         catalogue=False, min_levels=1
     ):
         """
@@ -969,7 +971,7 @@ def _themes(
         """
         self._load_tree_items()
         errors = set()
-        layers = self._layers(role_id, version, interface)
+        layers = self._layers(host_url, role_id, version, interface)
 
         themes = models.DBSession.query(main.Theme)
         themes = themes.filter(main.Theme.public.is_(True))
@@ -994,7 +996,7 @@ def _themes(
                 continue
 
             children, children_errors = self._get_children(
-                theme, layers, version, catalogue, min_levels, role_id
+                host_url, theme, layers, version, catalogue, min_levels, role_id
             )
             errors |= children_errors
 
@@ -1041,12 +1043,13 @@ def invalidate_cache():  # pragma: no cover
             "success": True
         }
 
-    def _get_children(self, theme, layers, version, catalogue, min_levels, role_id):
+    def _get_children(self, host_url, theme, layers, version, catalogue, min_levels, role_id):
         children = []
         errors = set()
         for item in theme.children:
             if isinstance(item, main.LayerGroup):
                 gp, gp_errors = self._group(
+                    host_url,
                     "{0!s}/{1!s}".format(theme.name, item.name),
                     item, layers,
                     role_id=role_id, version=version, catalogue=catalogue,
@@ -1161,14 +1164,15 @@ def _wfs_types_cached(self, wfs_url):
         except Exception:  # pragma: no cover
             return get_capabilities_xml, errors
 
-    def _functionality(self):
+    def _functionality(self, host_url):
         return self._functionality_cached(
-            self.request.user.role.name if self.request.user is not None else None
+            host_url, self.request.user.role.name if self.request.user is not None else None
         )
 
     @cache_region.cache_on_arguments()
-    def _functionality_cached(self, role):
+    def _functionality_cached(self, host_url, role):
         del role  # Just for caching
+        del host_url  # Just for caching
         functionality = {}
         for func_ in get_setting(
                 self.settings,
@@ -1235,7 +1239,7 @@ def get_cgxp_viewer_vars(self):
         role_id = self._get_role_id()
         interface = self.request.interface_name
 
-        themes, errors = self._themes(role_id, interface)
+        themes, errors = self._themes(self.request.host_url, role_id, interface)
         wfs_types, add_errors = self._internal_wfs_types(role_id)
         errors |= add_errors
 
@@ -1255,7 +1259,7 @@ def get_cgxp_viewer_vars(self):
             "user": self.request.user,
             "WFSTypes": json.dumps(wfs_types),
             "tiles_url": json.dumps(self.settings.get("tiles_url")),
-            "functionality": self._functionality(),
+            "functionality": self._functionality(self.request.host_url),
             "queryer_attribute_urls": json.dumps(self._get_layers_enum()),
             "serverError": json.dumps(list(errors)),
             "version_params": version_params,
@@ -1433,7 +1437,7 @@ def themes(self):
                 }
         if export_themes:
             themes, errors = self._themes(
-                role_id, interface, True, version, catalogue, min_levels
+                self.request.host_url, role_id, interface, True, version, catalogue, min_levels
             )
 
             if version == 1:
@@ -1443,13 +1447,15 @@ def themes(self):
             all_errors |= errors
 
         if export_group:
-            group, errors = self._get_group(group, role_id, interface, version)
+            group, errors = self._get_group(self.request.host_url, group, role_id, interface, version)
             if group is not None:
                 result["group"] = group
             all_errors |= errors
 
         if export_background:
-            group, errors = self._get_group(background_layers_group, role_id, interface, version)
+            group, errors = self._get_group(
+                self.request.host_url, background_layers_group, role_id, interface, version
+            )
             result["background_layers"] = group["children"] if group is not None else []
             all_errors |= errors
 
@@ -1458,12 +1464,12 @@ def themes(self):
             log.info("Theme errors:\n{}".format("\n".join(all_errors)))
         return result
 
-    def _get_group(self, group, role_id, interface, version):
-        layers = self._layers(role_id, version, interface)
+    def _get_group(self, host_url, group, role_id, interface, version):
+        layers = self._layers(host_url, role_id, version, interface)
         try:
             lg = models.DBSession.query(main.LayerGroup).filter(main.LayerGroup.name == group).one()
             return self._group(
-                lg.name, lg, layers,
+                host_url, lg.name, lg, layers,
                 role_id=role_id, version=version
             )
         except NoResultFound:  # pragma: no cover
@@ -1566,7 +1572,7 @@ def _user(self, user=None):
             "role_id": user.role.id
         } if user else {}
 
-        result["functionalities"] = self._functionality()
+        result["functionalities"] = self._functionality(self.request.host_url)
 
         return result
 

geoportal/tests/functional/test_entry.py

@@ -426,7 +426,7 @@ def test_theme(self):
         entry = Entry(request)
 
         # unautenticated
-        themes, errors = entry._themes(None, "desktop")
+        themes, errors = entry._themes('', None, "desktop")
         self.assertEqual(errors, {
             "The layer '__test_layer_in_group' (__test_layer_in_group) is not defined in WMS capabilities from '__test_ogc_server'",
         })
@@ -452,7 +452,7 @@ def test_theme(self):
         # authenticated
         request.params = {}
         request.user = DBSession.query(User).filter_by(username="__test_user1").one()
-        themes, errors = entry._themes(request.user.role.id)
+        themes, errors = entry._themes('', request.user.role.id)
         self.assertEqual(errors, {
             "The layer '__test_layer_in_group' (__test_layer_in_group) is not defined in WMS capabilities from '__test_ogc_server'",
         })
@@ -478,7 +478,7 @@ def test_notmapfile(self):
 
         from c2cgeoportal_geoportal.lib import caching
         caching.invalidate_region()
-        _, errors = entry._themes(None, "desktop")
+        _, errors = entry._themes('', None, "desktop")
         self.assertEqual({e[:43] for e in errors}, {
             "The layer '__test_public_layer' (__test_pub",
             "The layer '__test_layer_in_group' (__test_l",
@@ -541,7 +541,7 @@ def test_theme_geoserver(self):
         entry = Entry(request)
 
         # unautenticated v1
-        themes, errors = entry._themes(None, "desktop")
+        themes, errors = entry._themes('', None, "desktop")
         self.assertEqual(errors, set())
         self.assertEqual(len(themes), 1)
         layers = {l["name"] for l in themes[0]["children"][0]["children"]}
@@ -554,7 +554,7 @@ def test_theme_geoserver(self):
         # authenticated v1
         request.params = {}
         request.user = DBSession.query(User).filter_by(username="__test_user1").one()
-        themes, errors = entry._themes(request.user.role.id)
+        themes, errors = entry._themes('', request.user.role.id)
         self.assertEqual(errors, set())
         self.assertEqual(len(themes), 1)
         layers = {l["name"] for l in themes[0]["children"][0]["children"]}
@@ -935,7 +935,7 @@ def test_layer(self):
         entry = Entry(request)
 
         self.assertEqual(entry._group(
-            "", LayerGroup(), layers=[]), (None, set())
+            '', "", LayerGroup(), layers=[]), (None, set())
         )
 
         layer = LayerV1()
@@ -1234,7 +1234,7 @@ def test_layer(self):
         group.children = [layer_t1, layer_t2]
         time = TimeInformation()
         entry._group(
-            "", group, [layer_t1.name, layer_t2.name],
+            '', "", group, [layer_t1.name, layer_t2.name],
             time=time, mixed=False, depth=2
         )
         self.assertEqual(time.to_dict(), {
@@ -1355,7 +1355,7 @@ def test_layer(self):
         group2.children = [layer]
 
         self.assertEqual(entry._group(
-            "", group1, [layer.name],
+            '', "", group1, [layer.name],
         ), ({
             "id": 11,
             "isExpanded": False,
@@ -1409,23 +1409,23 @@ def test_internalwms(self):
         group2 = LayerGroup()
         group2.is_internal_wms = False
         group1.children = [group2]
-        _, errors = entry._group("", group1, [], catalogue=False)
+        _, errors = entry._group('', "", group1, [], catalogue=False)
         self._assert_has_error(errors, "Group '' cannot be in group '' (internal/external mix).")
 
         group1 = LayerGroup()
         group1.is_internal_wms = False
         group2 = LayerGroup()
         group2.is_internal_wms = True
         group1.children = [group2]
-        _, errors = entry._group("", group1, [], catalogue=False)
+        _, errors = entry._group('', "", group1, [], catalogue=False)
         self._assert_has_error(errors, "Group '' cannot be in group '' (internal/external mix).")
 
         group = LayerGroup()
         group.is_internal_wms = True
         layer = LayerV1()
         layer.layer_type = "internal WMS"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False)
         self.assertEqual(errors, {
             "The layer '' () is not defined in WMS capabilities from '__test_ogc_server'",
         })
@@ -1435,55 +1435,55 @@ def test_internalwms(self):
         layer = LayerV1()
         layer.layer_type = "external WMS"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False)
         self._assert_has_error(errors, "Layer '' cannot be in the group '' (internal/external mix).")
 
         group = LayerGroup()
         group.is_internal_wms = True
         layer = LayerV1()
         layer.layer_type = "WMTS"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False)
         self._assert_has_error(errors, "Layer '' cannot be in the group '' (internal/external mix).")
 
         group = LayerGroup()
         group.is_internal_wms = True
         layer = LayerV1()
         layer.layer_type = "no 2D"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False)
         self._assert_has_error(errors, "Layer '' cannot be in the group '' (internal/external mix).")
 
         group = LayerGroup()
         group.is_internal_wms = False
         layer = LayerV1()
         layer.layer_type = "internal WMS"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False)
         self._assert_has_error(errors, "Layer '' cannot be in the group '' (internal/external mix).")
 
         group = LayerGroup()
         group.is_internal_wms = False
         layer = LayerV1()
         layer.layer_type = "external WMS"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False, min_levels=0)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False, min_levels=0)
         self.assertEqual(errors, set())
 
         group = LayerGroup()
         group.is_internal_wms = False
         layer = LayerV1()
         layer.layer_type = "WMTS"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False, min_levels=0)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False, min_levels=0)
         self.assertEqual(errors, set())
 
         group = LayerGroup()
         group.is_internal_wms = False
         layer = LayerV1()
         layer.layer_type = "no 2D"
         group.children = [layer]
-        _, errors = entry._group("", group, [layer.name], catalogue=False, min_levels=0)
+        _, errors = entry._group('', "", group, [layer.name], catalogue=False, min_levels=0)
         self.assertEqual(errors, set())
 
     def test_loginchange_no_params(self):

geoportal/tests/functional/test_looptheme.py

@@ -97,5 +97,5 @@ def test_theme(self):
         request.client_addr = None
         request.user = None
         entry = Entry(request)
-        _, errors = entry._themes(None, "desktop2", True, 2)
+        _, errors = entry._themes('', None, "desktop2", True, 2)
         self.assertEqual(len([e for e in errors if e == "Too many recursions with group '__test_layer_group'"]), 1)