c2cgeoportal-geoportal 2.3.5.80__py3-none-any.whl → 2.9rc44__py3-none-any.whl

c2cgeoportal_geoportal/scripts/create_demo_theme.py

@@ -0,0 +1,83 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import argparse
+import logging
+
+import transaction
+
+from c2cgeoportal_geoportal.scripts import fill_arguments, get_appsettings, get_session
+
+_LOG = logging.getLogger(__name__)
+
+
+def main() -> None:
+    """Create and populate the database tables."""
+    parser = argparse.ArgumentParser(description="Create and populate the database tables.")
+    fill_arguments(parser)
+    options = parser.parse_args()
+    settings = get_appsettings(options)
+
+    with transaction.manager:
+        session = get_session(settings, transaction.manager)
+
+        from c2cgeoportal_commons.models.main import (  # pylint: disable=import-outside-toplevel
+            Interface,
+            LayerGroup,
+            LayerWMS,
+            OGCServer,
+            Theme,
+        )
+
+        interfaces = session.query(Interface).all()
+        ogc_jpeg = session.query(OGCServer).filter(OGCServer.name == "MapServer_JPEG").one()
+        session.delete(ogc_jpeg)
+
+        ogc_server_mapserver = session.query(OGCServer).filter(OGCServer.name == "MapServer").one()
+
+        layer_borders = LayerWMS("Borders", "borders")
+        layer_borders.interfaces = interfaces
+        layer_borders.ogc_server = ogc_server_mapserver
+        layer_density = LayerWMS("Density", "density")
+        layer_density.interfaces = interfaces
+        layer_density.ogc_server = ogc_server_mapserver
+
+        group_mapserver = LayerGroup("MapServer")
+        group_mapserver.children = [layer_borders, layer_density]
+
+        theme = Theme("Demo")
+        theme.children = [group_mapserver]
+        theme.interfaces = interfaces
+
+        session.add(theme)
+
+        print("Successfully added the demo theme")
+
+
+if __name__ == "__main__":
+    main()

c2cgeoportal_geoportal/scripts/manage_users.py

@@ -0,0 +1,140 @@
+# Copyright (c) 2011-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import argparse
+import sys
+from typing import cast
+
+import transaction
+
+from c2cgeoportal_geoportal.scripts import fill_arguments, get_appsettings, get_session
+
+
+def get_argparser() -> argparse.ArgumentParser:
+    """Get the argument parser for this script."""
+
+    usage = """Reset a user password.
+The username is used as password if the password is not provided with the corresponding option.
+User can be created if it does not exist yet."""
+
+    parser = argparse.ArgumentParser(description=usage)
+    fill_arguments(parser)
+    parser.add_argument("--password", "-p", help="Set password (if not set, username is used as password")
+    parser.add_argument(
+        "--create", "-c", action="store_true", default=False, help="Create user if it does not already exist"
+    )
+    parser.add_argument(
+        "--rolename", "-r", default="role_admin", help="The role name which must exist in the database"
+    )
+    parser.add_argument("--email", "-e", default=None, help="The user email")
+    parser.add_argument("user", help="The user")
+    return parser
+
+
+def main() -> None:
+    """
+    Emergency user create and password reset script example.
+
+    Reset toto password to foobar: docker compose
+    exec geoportal manage-users --password=foobar toto example, create user foo with password bar and role
+    admin: docker compose exec geoportal manage-users --create --rolename=role_admin --password=bar foo.
+
+    to get the options list, do: docker compose exec geoportal manage-users --help
+    """
+
+    parser = get_argparser()
+    options = parser.parse_args()
+    username = options.user
+    settings = get_appsettings(options)
+
+    with transaction.manager:
+        session = get_session(settings, transaction.manager)
+
+        # Must be done only once we have loaded the project config
+        from c2cgeoportal_commons.models.main import Role  # pylint: disable=import-outside-toplevel
+        from c2cgeoportal_commons.models.static import User  # pylint: disable=import-outside-toplevel
+
+        print("\n")
+
+        # Check that user exists
+        query = session.query(User).filter_by(username=username)
+
+        result = query.count()
+        if result == 0:
+            if not options.create:
+                # If doesn't exist and no -c option, throw error
+                print(f"User {username} does not exist in database")
+                sys.exit(1)
+            else:
+                if options.password is None:
+                    parser.error("The password is mandatory on user creation")
+                if options.email is None:
+                    parser.error("The email is mandatory on user creation")
+
+                # Get roles
+                query_role = session.query(Role).filter(Role.name == options.rolename)
+
+                if query_role.count() == 0:
+                    # Role not found in db?
+                    print(f"Role matching {options.rolename} does not exist in database")
+                    sys.exit(1)
+
+                role = query_role.first()
+                assert role is not None
+
+                user = User(
+                    username=username,
+                    password=cast(str, options.password),
+                    email=cast(str, options.email),
+                    settings_role=role,
+                    roles=[role],
+                )
+                session.add(user)
+
+                print(f"User {username} created with password {options.password} and role {options.rolename}")
+
+        else:
+            # If user exists (assuming username are unique)
+            first_user = query.first()
+            assert first_user is not None
+            user = first_user
+
+            if options.password is not None:
+                print(f"Password set to: {options.password}")
+                user.password = f"{options.password}"
+
+            if options.email is not None:
+                user.email = options.email
+
+            session.add(user)
+
+            print(f"Password reset for user {username}")
+
+
+if __name__ == "__main__":
+    main()

c2cgeoportal_geoportal/scripts/pcreate.py

@@ -0,0 +1,296 @@
+# Copyright (c) 2021-2024, Camptocamp SA
+# All rights reserved.
+
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+
+# 1. Redistributions of source code must retain the above copyright notice, this
+#    list of conditions and the following disclaimer.
+# 2. Redistributions in binary form must reproduce the above copyright notice,
+#    this list of conditions and the following disclaimer in the documentation
+#    and/or other materials provided with the distribution.
+
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+# DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+# ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+# SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+# The views and conclusions contained in the software and documentation are those
+# of the authors and should not be interpreted as representing official policies,
+# either expressed or implied, of the FreeBSD Project.
+
+
+import os
+import re
+import subprocess
+import sys
+from argparse import ArgumentParser
+from typing import Any, Union, cast
+
+import pkg_resources
+import pyproj
+import yaml
+from cookiecutter.log import configure_logger
+from cookiecutter.main import cookiecutter
+
+_bad_chars_re = re.compile("[^a-zA-Z0-9_]")
+SCAFFOLDS_DIR = pkg_resources.resource_filename("c2cgeoportal_geoportal", "scaffolds")
+
+
+def get_argparser() -> ArgumentParser:
+    """Get the argument parser for this script."""
+
+    parser = ArgumentParser(
+        prog=sys.argv[0],
+        add_help=True,
+        description="Wrapper around cookiecutter that create appropriated context.",
+    )
+    parser.add_argument(
+        "-s",
+        "--scaffold",
+        dest="scaffold_names",
+        action="append",
+        help=("Add a scaffold to the create process " "(multiple -s args accepted)"),
+    )
+    parser.add_argument(
+        "-l",
+        "--list",
+        dest="list",
+        action="store_true",
+        help="List all available scaffold names",
+    )
+    parser.add_argument(
+        "--package-name",
+        dest="package_name",
+        action="store",
+        help="Package name to use. The name provided is "
+        "assumed to be a valid Python package name, and "
+        "will not be validated. By default the package "
+        "name is derived from the value of "
+        "output_directory.",
+    )
+    parser.add_argument(
+        "--overwrite",
+        dest="overwrite",
+        action="store_true",
+        help="Always overwrite",
+    )
+    parser.add_argument(
+        "output_directory",
+        nargs="?",
+        default=None,
+        help="The directory where the project will be " "created.",
+    )
+    return parser
+
+
+def main() -> int:
+    """Entry point to run PCreateCommand."""
+    command = PCreateCommand(sys.argv)
+    try:
+        return command.run()
+    except KeyboardInterrupt:  # pragma: no cover
+        return 1
+
+
+class PCreateCommand:
+    """
+    Wrapper around cookiecutter with appropriated context creator for our scaffolds.
+
+    This is a port of Pyramid 1 PCreateCommand using cookiecutter as a backend.
+    """
+
+    def __init__(self, argv: list[str], quiet: bool = False) -> None:
+        self.quiet = quiet
+        self.parser = get_argparser()
+        self.args = self.parser.parse_args(argv[1:])
+        self.scaffolds = self.all_scaffolds()
+
+    def run(self) -> int:
+        if self.args.list:
+            return self.show_scaffolds()
+        if not self.args.scaffold_names and not self.args.output_directory:
+            if not self.quiet:  # pragma: no cover
+                self.parser.print_help()
+                self.out("")
+                self.show_scaffolds()
+            return 2
+
+        return self.render_scaffolds()
+
+    @property
+    def output_path(self) -> str:
+        return cast(str, os.path.abspath(os.path.normpath(self.args.output_directory)))
+
+    def render_scaffolds(self) -> int:
+        verbose = True
+        debug_file = None
+        configure_logger(stream_level="DEBUG" if verbose else "INFO", debug_file=debug_file)
+
+        context = self.get_context()
+
+        for scaffold_name in self.args.scaffold_names:
+            # Needed to be backward compatible for the `test-upgrade init` command
+            if scaffold_name.startswith("c2cgeoportal_"):
+                scaffold_name = scaffold_name[len("c2cgeoportal_") :]
+            self.out(f"Rendering scaffold: {scaffold_name}")
+            cookiecutter(
+                template=os.path.join(SCAFFOLDS_DIR, scaffold_name),
+                extra_context=context,
+                no_input=True,
+                overwrite_if_exists=self.args.overwrite,
+                output_dir=os.path.dirname(self.output_path),
+            )
+        return 0
+
+    def show_scaffolds(self) -> int:
+        scaffolds = sorted(self.scaffolds)
+        if scaffolds:
+            self.out("Available scaffolds:")
+            for scaffold in scaffolds:
+                self.out(f"  {scaffold}")
+        else:
+            self.out("No scaffolds available")
+        return 0
+
+    @staticmethod
+    def all_scaffolds() -> list[str]:
+        return os.listdir(SCAFFOLDS_DIR)
+
+    def out(self, msg: str) -> None:
+        if not self.quiet:
+            print(msg)
+
+    def get_context(self) -> dict[str, str | int]:
+        output_dir = self.output_path
+        project_name = os.path.basename(output_dir)
+        if self.args.package_name is None:
+            pkg_name = _bad_chars_re.sub("", project_name.lower().replace("-", "_"))
+        else:
+            pkg_name = self.args.package_name
+
+        context: dict[str, str | int] = {
+            "project": project_name,
+            "package": pkg_name,
+            "authtkt_secret": gen_authtkt_secret(),
+        }
+        context.update(self.read_project_file())
+        if os.environ.get("CI") == "true":
+            context["authtkt_secret"] = (  # nosec
+                "io7heoDui8xaikie1rushaeGeiph8Bequei6ohchaequob6viejei0xooWeuvohf"
+            )
+
+        self.get_var(context, "srid", "Spatial Reference System Identifier (e.g. 2056): ", int)
+        srid = cast(int, context["srid"])
+        extent = self.epsg2bbox(srid)
+        self.get_var(
+            context,
+            "extent",
+            (
+                f"Extent (minx miny maxx maxy): in EPSG: {srid} projection, default is "
+                f"[{extent[0]} {extent[1]} {extent[2]} {extent[3]}]: "
+                if extent
+                else f"Extent (minx miny maxx maxy): in EPSG: {srid} projection: "
+            ),
+        )
+        match = re.match(
+            r"([\d.]+)[,; ] *([\d.]+)[,; ] *([\d.]+)[,; ] *([\d.]+)",
+            cast(str, context["extent"]),
+        )
+        if match is not None:
+            extent = [match.group(n + 1) for n in range(4)]
+        assert extent is not None
+        context["extent"] = ",".join(extent)
+        context["extent_mapserver"] = " ".join(extent)
+
+        if context["package"] == "site":
+            raise ValueError(
+                "Sorry, you may not name your package 'site'. "
+                "The package name 'site' has a special meaning in "
+                "Python.  Please name it anything except 'site'."
+            )
+
+        package_logger = context["package"]
+        if package_logger == "root":
+            # Rename the app logger in the rare case a project
+            # is named "root"
+            package_logger = "app"
+        context["package_logger"] = package_logger
+        context["geomapfish_version"] = os.environ["VERSION"]
+        # Used in the Docker files to shoos the version of the build image
+        context["geomapfish_version_tag"] = "GEOMAPFISH_VERSION"
+        context["geomapfish_version_tag_env"] = "${GEOMAPFISH_VERSION}"
+        geomapfish_major_version_tag = (
+            "GEOMAPFISH_VERSION"
+            if context.get("unsafe_long_version", False)
+            else "GEOMAPFISH_MAIN_MINOR_VERSION"
+        )
+        # Used in the Docker files to shoos the version of the run image
+        context["geomapfish_major_version_tag"] = geomapfish_major_version_tag
+        context["geomapfish_major_version_tag_env"] = "${" + geomapfish_major_version_tag + "}"
+        context["geomapfish_main_version"] = os.environ["MAJOR_VERSION"]
+        context["geomapfish_main_version_dash"] = os.environ["MAJOR_VERSION"].replace(".", "-")
+        context["geomapfish_main_minor_version"] = os.environ["MAJOR_MINOR_VERSION"]
+
+        return context
+
+    def read_project_file(self) -> dict[str, str | int]:
+        project_file = os.path.join(self.output_path, "project.yaml")
+        if os.path.exists(project_file):
+            with open(project_file, encoding="utf8") as f:
+                project = yaml.safe_load(f)
+                return cast(dict[str, Union[str, int]], project.get("template_vars", {}))
+        else:
+            return {}
+
+    @staticmethod
+    def get_var(
+        context: dict[str, Any],
+        name: str,
+        prompt: str,
+        type_: type[Any] | None = None,
+    ) -> None:
+        if name.upper() in os.environ and os.environ[name.upper()] != "":
+            value = os.environ.get(name.upper())
+        else:
+            value = context.get(name)
+
+        if value is None:
+            value = input(prompt).strip()
+
+        if type_ is not None and not isinstance(value, type_):
+            try:
+                value = type_(value)
+            except ValueError:
+                print(f"The attribute {name}={value} is not a {type_}")
+                sys.exit(1)
+
+        context[name] = value
+
+    @staticmethod
+    def epsg2bbox(srid: int) -> list[str] | None:
+        try:
+            crs = pyproj.CRS.from_epsg(srid)
+            assert crs.area_of_use is not None
+            transformer = pyproj.Transformer.from_crs(4326, crs)
+            c1 = transformer.transform(crs.area_of_use.bounds[1], crs.area_of_use.bounds[0])
+            c2 = transformer.transform(crs.area_of_use.bounds[3], crs.area_of_use.bounds[2])
+            return [c1[0], c1[1], c2[0], c2[1]]
+        except Exception as exception:  # pylint: disable=broad-exception-caught
+            print(f"Unexpected error: {str(exception)}")
+        return None
+
+
+def gen_authtkt_secret() -> str:
+    """Generate a random authtkt secret."""
+    return subprocess.run(["pwgen", "64"], stdout=subprocess.PIPE, check=True).stdout.decode().strip()
+
+
+if __name__ == "__main__":  # pragma: no cover
+    sys.exit(main() or 0)