def _functionality(
self
) -> Dict[str, List[Union[str, int, float, bool, List[Any], Dict[str,
Any]]]]:
functionality = {}
for func_ in get_setting(self.settings,
("functionalities", "available_in_templates"),
[]):
functionality[func_] = get_functionality(func_, self.request,
is_intranet(self.request))
return functionality
def capabilities(self) -> pyramid.response.Response:
""" Get print capabilities. """
templates = get_functionality("print_template", self.request,
is_intranet(self.request))
# get query string
params = dict(self.request.params)
query_string = urllib.parse.urlencode(params)
resp, content = self._capabilities(templates, query_string,
self.request.method)
return self._build_response(resp, content, Cache.PRIVATE, "print")
def capabilities(self) -> pyramid.response.Response:
"""Get print capabilities."""
templates = get_functionality("print_template", self.request,
is_intranet(self.request))
# get query string
params = dict(self.request.params)
query_string = urllib.parse.urlencode(params)
resp, content = self._capabilities(templates, query_string,
self.request.method,
self.request.referrer)
response = self._build_response(resp, content, Cache.PRIVATE, "print")
# Mapfish print will check the referer header to return the capabilities.
response.vary += ("Referer", )
return response
def _user(self, user: Optional[static.User] = None) -> Dict[str, Any]:
result = {
"functionalities": self._functionality(),
"is_intranet": is_intranet(self.request),
"two_factor_enable": self.two_factor_auth,
}
user = self.request.user if user is None else user
if user is not None:
result.update({
"username":
user.username,
"email":
user.email,
"roles": [{
"name": r.name,
"id": r.id
} for r in user.roles],
})
return result
def get_mapserver_substitution_params(
request: pyramid.request.Request) -> Dict[str, str]:
params: Dict[str, str] = {}
mss = get_functionality("mapserver_substitution", request,
is_intranet(request))
if mss:
for s_ in mss:
s = cast(str, s_)
index = s.find("=")
if index > 0:
attribute = "s_" + s[:index]
value = s[index + 1:]
if attribute in params:
params[attribute] += "," + value
else:
params[attribute] = value
else:
LOG.warning(
"Mapserver Substitution '%s' does not "
"respect pattern: <attribute>=<value>", s)
return params
def themes(self) -> Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]]:
interface = self.request.params.get("interface", "desktop")
sets = self.request.params.get("set", "all")
min_levels = int(self.request.params.get("min_levels", 1))
group = self.request.params.get("group")
background_layers_group = self.request.params.get("background")
set_common_headers(self.request, "themes", Cache.PRIVATE)
async def get_theme() -> Dict[str, Union[Dict[str, Any], List[str]]]:
export_themes = sets in ("all", "themes")
export_group = group is not None and sets in ("all", "group")
export_background = background_layers_group is not None and sets in ("all", "background")
result: Dict[str, Union[Dict[str, Any], List[Any]]] = {}
all_errors: Set[str] = set()
LOG.debug("Start preload")
start_time = time.time()
await self.preload(all_errors)
LOG.debug("End preload")
# Don't log if it looks to be already preloaded.
if (time.time() - start_time) > 1:
LOG.info("Do preload in %.3fs.", time.time() - start_time)
result["ogcServers"] = {}
for ogc_server in models.DBSession.query(main.OGCServer).all():
nb_layers = (
models.DBSession.query(sqlalchemy.func.count(main.LayerWMS.id))
.filter(main.LayerWMS.ogc_server_id == ogc_server.id)
.one()
)
if nb_layers[0] == 0:
# QGIS Server langing page requires an OGC server that can't be used here.
continue
url_internal_wfs, url, url_wfs = self.get_url_internal_wfs(ogc_server, all_errors)
attributes = None
namespace = None
if ogc_server.wfs_support:
assert url_internal_wfs
attributes, namespace, errors = await self._get_features_attributes(
url_internal_wfs, ogc_server.name
)
# Create a local copy (don't modify the cache)
if attributes is not None:
attributes = dict(attributes)
all_errors |= errors
all_private_layers = get_private_layers([ogc_server.id]).values()
protected_layers_name = [
layer.name for layer in get_protected_layers(self.request, [ogc_server.id]).values()
]
private_layers_name: List[str] = []
for layers in [
v.layer for v in all_private_layers if v.name not in protected_layers_name
]:
private_layers_name.extend(layers.split(","))
if attributes is not None:
for name in private_layers_name:
if name in attributes:
del attributes[name]
result["ogcServers"][ogc_server.name] = {
"url": url.url() if url else None,
"urlWfs": url_wfs.url() if url_wfs else None,
"type": ogc_server.type,
"credential": ogc_server.auth != main.OGCSERVER_AUTH_NOAUTH,
"imageType": ogc_server.image_type,
"wfsSupport": ogc_server.wfs_support,
"isSingleTile": ogc_server.is_single_tile,
"namespace": namespace,
"attributes": attributes,
}
if export_themes:
themes, errors = await self._themes(interface, True, min_levels)
result["themes"] = themes
all_errors |= errors
if export_group:
exported_group, errors = await self._get_group(group, interface)
if exported_group is not None:
result["group"] = exported_group
all_errors |= errors
if export_background:
exported_group, errors = await self._get_group(background_layers_group, interface)
result["background_layers"] = exported_group["children"] if exported_group is not None else []
all_errors |= errors
result["errors"] = list(all_errors)
if all_errors:
LOG.info("Theme errors:\n%s", "\n".join(all_errors))
return result
@CACHE_REGION.cache_on_arguments() # type: ignore
def get_theme_anonymous(
intranet: bool,
interface: str,
sets: str,
min_levels: str,
group: str,
background_layers_group: str,
host: str,
) -> Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]]:
# Only for cache key
del intranet, interface, sets, min_levels, group, background_layers_group, host
return asyncio.run(get_theme())
if self.request.user is None:
return cast(
Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]],
get_theme_anonymous(
is_intranet(self.request),
interface,
sets,
min_levels,
group,
background_layers_group,
self.request.headers.get("Host"),
),
)
return asyncio.run(get_theme())
def themes(self):
interface = self.request.params.get("interface", "desktop")
sets = self.request.params.get("set", "all")
min_levels = int(self.request.params.get("min_levels", 1))
group = self.request.params.get("group")
background_layers_group = self.request.params.get("background")
set_common_headers(self.request, "themes", PRIVATE_CACHE)
def get_theme():
export_themes = sets in ("all", "themes")
export_group = group is not None and sets in ("all", "group")
export_background = background_layers_group is not None and sets in (
"all", "background")
result: Dict[str, Union[Dict[str, Dict[str, Any]], List[str]]] = {}
all_errors: Set[str] = set()
LOG.debug("Start preload")
start_time = time.time()
asyncio.run(self.preload(all_errors))
LOG.debug("End preload")
LOG.info("Do preload in %.3fs.", time.time() - start_time)
result["ogcServers"] = {}
for ogc_server in models.DBSession.query(main.OGCServer).all():
url_internal_wfs, url, url_wfs = self.get_url_internal_wfs(
ogc_server, all_errors)
attributes = None
namespace = None
if ogc_server.wfs_support:
attributes, namespace, errors = self._get_features_attributes(
url_internal_wfs)
all_errors |= errors
all_private_layers = get_private_layers([ogc_server.id
]).values()
protected_layers_name = [
l.name for l in get_protected_layers(
self.request, [ogc_server.id]).values()
]
private_layers_name: List[str] = []
for layers in [
v.layer for v in all_private_layers
if v.name not in protected_layers_name
]:
private_layers_name.extend(layers.split(","))
if attributes is not None:
for name in private_layers_name:
if name in attributes:
del attributes[name]
result["ogcServers"][ogc_server.name] = {
"url": url,
"urlWfs": url_wfs,
"type": ogc_server.type,
"credential":
ogc_server.auth != main.OGCSERVER_AUTH_NOAUTH,
"imageType": ogc_server.image_type,
"wfsSupport": ogc_server.wfs_support,
"isSingleTile": ogc_server.is_single_tile,
"namespace": namespace,
"attributes": attributes,
}
if export_themes:
themes, errors = self._themes(interface, True, min_levels)
result["themes"] = themes
all_errors |= errors
if export_group:
exported_group, errors = self._get_group(group, interface)
if exported_group is not None:
result["group"] = exported_group
all_errors |= errors
if export_background:
exported_group, errors = self._get_group(
background_layers_group, interface)
result["background_layers"] = exported_group[
"children"] if exported_group is not None else []
all_errors |= errors
result["errors"] = list(all_errors)
if all_errors:
LOG.info("Theme errors:\n%s", "\n".join(all_errors))
return result
@CACHE_REGION.cache_on_arguments()
def get_theme_anonymous(intranet, interface, sets, min_levels, group,
background_layers_group, host):
# Only for cache key
del intranet, interface, sets, min_levels, group, background_layers_group, host
return get_theme()
if self.request.user is None:
return get_theme_anonymous(
is_intranet(self.request),
interface,
sets,
min_levels,
group,
background_layers_group,
self.request.headers.get("Host"),
)
return get_theme()