OpenGeodeWeb-Back 6.15.3rc1__tar.gz → 6.16.0__tar.gz

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.15.3rc1
+Version: 6.16.0
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "OpenGeodeWeb-Back"
-version = "6.15.3-rc.1"
+version = "6.16.0"
 dynamic = ["dependencies"]
 authors = [{ name = "Geode-solutions", email = "team-web@geode-solutions.com" }]
 description = "OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem"

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/OpenGeodeWeb_Back.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: OpenGeodeWeb-Back
-Version: 6.15.3rc1
+Version: 6.16.0
 Summary: OpenGeodeWeb-Back is an open source framework that proposes handy python functions and wrappers for the OpenGeode ecosystem
 Author-email: Geode-solutions <team-web@geode-solutions.com>
 Project-URL: Homepage, https://github.com/Geode-solutions/OpenGeodeWeb-Back

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/OpenGeodeWeb_Back.egg-info/SOURCES.txt

@@ -67,8 +67,12 @@ src/opengeodeweb_back/routes/schemas/allowed_files.json
 src/opengeodeweb_back/routes/schemas/allowed_files.py
 src/opengeodeweb_back/routes/schemas/allowed_objects.json
 src/opengeodeweb_back/routes/schemas/allowed_objects.py
+src/opengeodeweb_back/routes/schemas/apply_time_series.json
+src/opengeodeweb_back/routes/schemas/apply_time_series.py
 src/opengeodeweb_back/routes/schemas/cell_attribute_names.json
 src/opengeodeweb_back/routes/schemas/cell_attribute_names.py
+src/opengeodeweb_back/routes/schemas/data_missing_files.json
+src/opengeodeweb_back/routes/schemas/data_missing_files.py
 src/opengeodeweb_back/routes/schemas/edge_attribute_names.json
 src/opengeodeweb_back/routes/schemas/edge_attribute_names.py
 src/opengeodeweb_back/routes/schemas/export_project.json
@@ -83,8 +87,6 @@ src/opengeodeweb_back/routes/schemas/import_project.json
 src/opengeodeweb_back/routes/schemas/import_project.py
 src/opengeodeweb_back/routes/schemas/kill.json
 src/opengeodeweb_back/routes/schemas/kill.py
-src/opengeodeweb_back/routes/schemas/missing_files.json
-src/opengeodeweb_back/routes/schemas/missing_files.py
 src/opengeodeweb_back/routes/schemas/model_component_edge_attribute_names.json
 src/opengeodeweb_back/routes/schemas/model_component_edge_attribute_names.py
 src/opengeodeweb_back/routes/schemas/model_component_polygon_attribute_names.json
@@ -103,6 +105,10 @@ src/opengeodeweb_back/routes/schemas/save_viewable_file.json
 src/opengeodeweb_back/routes/schemas/save_viewable_file.py
 src/opengeodeweb_back/routes/schemas/texture_coordinates.json
 src/opengeodeweb_back/routes/schemas/texture_coordinates.py
+src/opengeodeweb_back/routes/schemas/time_series_allowed_objects.json
+src/opengeodeweb_back/routes/schemas/time_series_allowed_objects.py
+src/opengeodeweb_back/routes/schemas/time_series_missing_files.json
+src/opengeodeweb_back/routes/schemas/time_series_missing_files.py
 src/opengeodeweb_back/routes/schemas/upload_file.json
 src/opengeodeweb_back/routes/schemas/upload_file.py
 src/opengeodeweb_back/routes/schemas/validate.json

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/opengeodeweb_back/geode_functions.py

@@ -58,9 +58,12 @@ def get_data_info(data_id: str) -> Data:
 
 
 def upload_file_path(filename: str) -> str:
-    upload_folder = flask.current_app.config["UPLOAD_FOLDER_PATH"]
-    secure_filename = werkzeug.utils.secure_filename(filename)
-    return str((Path(upload_folder) / secure_filename).resolve())
+    upload_folder = Path(flask.current_app.config["UPLOAD_FOLDER_PATH"]).resolve()
+    segments = [werkzeug.utils.secure_filename(segment) for segment in filename.split("/")]
+    safe_segments = [segment for segment in segments if segment]
+    if not safe_segments:
+        flask.abort(400, f"Invalid filename: {filename}")
+    return str(upload_folder.joinpath(*safe_segments))
 
 
 def geode_object_output_extensions(

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/opengeodeweb_back/geode_objects/geode_brep.py

@@ -57,6 +57,17 @@ class GeodeBRep(GeodeModel):
     def additional_files(cls, filename: str) -> og.AdditionalFiles:
         return og.brep_additional_files(filename)
 
+    @classmethod
+    def time_series_input_extensions(cls) -> list[str]:
+        return og.BRepTimeSeriesInputFactory.list_creators()
+
+    @classmethod
+    def time_series_additional_files(cls, filename: str) -> og.AdditionalFiles:
+        return og.brep_time_series_additional_files(filename)
+
+    def load_time_series(self, filename: str) -> None:
+        og.load_brep_time_series(self.brep, filename)
+
     @override
     @classmethod
     def is_loadable(cls, filename: str) -> og.Percentage:

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/opengeodeweb_back/routes/blueprint_routes.py

@@ -28,6 +28,7 @@ from sqlalchemy.exc import OperationalError
 # Local application imports
 from opengeodeweb_back import geode_functions, utils_functions
 from opengeodeweb_back.geode_objects import geode_objects
+from opengeodeweb_back.geode_objects.geode_brep import GeodeBRep
 from opengeodeweb_back.geode_objects.geode_graph import GeodeGraph
 from opengeodeweb_back.geode_objects.geode_grid2d import GeodeGrid2D
 from opengeodeweb_back.geode_objects.geode_grid3d import GeodeGrid3D
@@ -42,6 +43,7 @@ from opengeodeweb_back.typed_route import parse_params, raw_route, typed_route
 if TYPE_CHECKING:
     from werkzeug.datastructures import FileStorage
 
+
 ComponentMesh = (
     og.Corner2D,
     og.Corner3D,
@@ -62,11 +64,14 @@ routes = flask.Blueprint("routes", __name__, url_prefix="/opengeodeweb_back")
 
 @typed_route(routes, schemas.allowed_files_route)
 def allowed_files(_params: schemas.AllowedFiles) -> schemas.AllowedFilesResponse:
-    extensions: set[str] = set()
+    data_extensions: set[str] = set()
     for geode_object in geode_objects.values():
-        for extension in geode_object.input_extensions():
-            extensions.add(extension)
-    return schemas.AllowedFilesResponse(extensions=list(extensions))
+        data_extensions.update(geode_object.input_extensions())
+    # Time series files are applied on an existing BRep, not imported as data
+    return schemas.AllowedFilesResponse(
+        data_extensions=list(data_extensions),
+        time_series_extensions=GeodeBRep.time_series_input_extensions(),
+    )
 
 
 def _write_stream(path: Path, stream: typing.IO[bytes], mode: str = "wb") -> None:
@@ -101,21 +106,23 @@ def upload_file() -> flask.Response:
         file = flask.request.files["file"]
         if file.filename is None:
             flask.abort(400, "Filename is required")
-        filename = werkzeug.utils.secure_filename(Path(file.filename).name)
-        file_path = Path(upload_folder_path) / filename
+        # Only the name is kept: some multipart clients send their full local path.
+        # Relative paths (folder uploads) go through the raw upload below.
+        file_path = Path(geode_functions.upload_file_path(Path(file.filename).name))
+        file_path.parent.mkdir(parents=True, exist_ok=True)
         file.save(file_path)
-        return _finalize_upload(filename)
+        return _finalize_upload(file_path.name)
 
     raw_filename = flask.request.args.get("filename")
     if not raw_filename:
         flask.abort(400, "Filename is required")
-    filename = werkzeug.utils.secure_filename(Path(raw_filename).name)
-    file_path = Path(upload_folder_path) / filename
+    file_path = Path(geode_functions.upload_file_path(raw_filename))
+    file_path.parent.mkdir(parents=True, exist_ok=True)
 
     total_chunks = flask.request.args.get("total_chunks", type=int)
     if total_chunks is None:
         _write_stream(file_path, flask.request.stream)
-        return _finalize_upload(filename)
+        return _finalize_upload(file_path.name)
 
     chunk_index = flask.request.args.get("chunk_index", type=int)
     if chunk_index is None or not 0 <= chunk_index < total_chunks:
@@ -127,7 +134,18 @@ def upload_file() -> flask.Response:
         return _upload_response("Chunk received", 200)
 
     part_path.replace(file_path)
-    return _finalize_upload(filename)
+    return _finalize_upload(file_path.name)
+
+
+@typed_route(routes, schemas.time_series_allowed_objects_route)
+def time_series_allowed_objects(
+    params: schemas.TimeSeriesAllowedObjects,
+) -> schemas.TimeSeriesAllowedObjectsResponse:
+    extension = utils_functions.extension_from_filename(params.filename)
+    is_readable = extension in GeodeBRep.time_series_input_extensions()
+    return schemas.TimeSeriesAllowedObjectsResponse(
+        allowed_objects=[GeodeBRep.geode_object_type()] if is_readable else []
+    )
 
 
 @typed_route(routes, schemas.allowed_objects_route)
@@ -149,28 +167,69 @@ def allowed_objects(
     return schemas.AllowedObjectsResponse(allowed_objects=allowed_objects)
 
 
-@typed_route(routes, schemas.missing_files_route)
-def missing_files(params: schemas.MissingFiles) -> schemas.MissingFilesResponse:
-    file_path = geode_functions.upload_file_path(params.filename)
+def _check_time_series_extension(filename: str) -> None:
+    extension = utils_functions.extension_from_filename(filename)
+    if extension not in GeodeBRep.time_series_input_extensions():
+        flask.abort(400, f"No time series reader for .{extension}")
+
+
+def _resolved_path(file_path: str, main_file: Path) -> Path:
+    path = Path(file_path)
+    if not path.is_absolute():
+        path = main_file.parent / path
+    return path.resolve()
+
+
+def _path_relative_to_main_file(file_path: str, main_file: Path) -> str:
+    path = _resolved_path(file_path, main_file)
+    if path.is_relative_to(main_file.parent):
+        return path.relative_to(main_file.parent).as_posix()
+    return path.name
+
+
+def _missing_files(additional_files: og.AdditionalFiles, main_file: Path) -> dict[str, typing.Any]:
+    return {
+        "has_missing_files": any(
+            file.is_missing
+            for file in additional_files.mandatory_files + additional_files.optional_files
+        ),
+        "mandatory_files": [
+            _path_relative_to_main_file(file.filename, main_file)
+            for file in additional_files.mandatory_files
+            if file.is_missing
+        ],
+        "additional_files": [
+            _path_relative_to_main_file(file.filename, main_file)
+            for file in additional_files.optional_files
+            if file.is_missing
+        ],
+    }
+
+
+@typed_route(routes, schemas.data_missing_files_route)
+def data_missing_files(params: schemas.DataMissingFiles) -> schemas.DataMissingFilesResponse:
+    file_path = Path(geode_functions.upload_file_path(params.filename))
     geode_object = geode_functions.geode_object_from_string(params.geode_object_type)
-    additional_files = geode_object.additional_files(
-        file_path,
-    )
-    has_missing_files = any(
-        file.is_missing
+    additional_files = geode_object.additional_files(str(file_path))
+    return schemas.DataMissingFilesResponse.from_dict(_missing_files(additional_files, file_path))
+
+
+@typed_route(routes, schemas.time_series_missing_files_route)
+def time_series_missing_files(
+    params: schemas.TimeSeriesMissingFiles,
+) -> schemas.TimeSeriesMissingFilesResponse:
+    file_path = Path(geode_functions.upload_file_path(params.filename))
+    _check_time_series_extension(file_path.name)
+    additional_files = GeodeBRep.time_series_additional_files(str(file_path))
+    # Uploads always land under the time series file's folder:
+    # files referenced outside of it could never be provided
+    if any(
+        not _resolved_path(file.filename, file_path).is_relative_to(file_path.parent)
         for file in additional_files.mandatory_files + additional_files.optional_files
-    )
-    mandatory_files = [
-        Path(file.filename).name for file in additional_files.mandatory_files if file.is_missing
-    ]
-    additional_files_array = [
-        Path(file.filename).name for file in additional_files.optional_files if file.is_missing
-    ]
-
-    return schemas.MissingFilesResponse(
-        has_missing_files=has_missing_files,
-        mandatory_files=mandatory_files,
-        additional_files=additional_files_array,
+    ):
+        flask.abort(400, f"{file_path.name} references files outside its folder")
+    return schemas.TimeSeriesMissingFilesResponse.from_dict(
+        _missing_files(additional_files, file_path)
     )
 
 
@@ -235,6 +294,23 @@ def save_viewable_file(
     )
 
 
+@typed_route(routes, schemas.apply_time_series_route)
+def apply_time_series(
+    params: schemas.ApplyTimeSeries,
+) -> schemas.ApplyTimeSeriesResponse:
+    data = geode_functions.get_data_info(params.id)
+    _check_time_series_extension(params.filename)
+    if data.geode_object != GeodeBRep.geode_object_type():
+        flask.abort(400, f"{data.geode_object} is not a BRep: time series cannot be applied")
+    geode_object = GeodeBRep.load(geode_functions.data_file_path(params.id, data.native_file))
+    # Applied in memory first: if OpenGeode fails, nothing is written.
+    geode_object.load_time_series(geode_functions.upload_file_path(params.filename))
+    utils_functions.save_all_viewables_and_return_info(
+        geode_object, data, geode_functions.data_file_path(params.id)
+    )
+    return schemas.ApplyTimeSeriesResponse()
+
+
 @typed_route(routes, schemas.texture_coordinates_route)
 def texture_coordinates(
     params: schemas.TextureCoordinates,

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/opengeodeweb_back/routes/schemas/__init__.py

@@ -1,6 +1,8 @@
 from .vertex_attribute_names import *
 from .validate import *
 from .upload_file import *
+from .time_series_missing_files import *
+from .time_series_allowed_objects import *
 from .texture_coordinates import *
 from .save_viewable_file import *
 from .polyhedron_attribute_names import *
@@ -10,7 +12,6 @@ from .model_component_vertex_attribute_names import *
 from .model_component_polyhedron_attribute_names import *
 from .model_component_polygon_attribute_names import *
 from .model_component_edge_attribute_names import *
-from .missing_files import *
 from .kill import *
 from .import_project import *
 from .geographic_coordinate_systems import *
@@ -18,6 +19,8 @@ from .geode_objects_and_output_extensions import *
 from .geode_object_inheritance import *
 from .export_project import *
 from .edge_attribute_names import *
+from .data_missing_files import *
 from .cell_attribute_names import *
+from .apply_time_series import *
 from .allowed_objects import *
 from .allowed_files import *

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/opengeodeweb_back/routes/schemas/allowed_files.json

@@ -10,7 +10,13 @@
   "response": {
     "type": "object",
     "properties": {
-      "extensions": {
+      "data_extensions": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "time_series_extensions": {
         "type": "array",
         "items": {
           "type": "string"
@@ -18,8 +24,9 @@
       }
     },
     "required": [
-      "extensions"
+      "data_extensions",
+      "time_series_extensions"
     ],
     "additionalProperties": false
   }
-}
+}

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/src/opengeodeweb_back/routes/schemas/allowed_files.py

@@ -19,7 +19,8 @@ class AllowedFilesResponse(DataClassJsonMixin):
     def __post_init__(self) -> None:
         print_dataclass(self)
 
-    extensions: List[str]
+    data_extensions: List[str]
+    time_series_extensions: List[str]
 
 
 allowed_files_route = Route(

opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/apply_time_series.json

@@ -0,0 +1,29 @@
+{
+  "route": "/apply_time_series",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {
+    "id": {
+      "type": "string",
+      "minLength": 32,
+      "maxLength": 32
+    },
+    "filename": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": [
+    "id",
+    "filename"
+  ],
+  "additionalProperties": false,
+  "response": {
+    "type": "object",
+    "properties": {},
+    "required": [],
+    "additionalProperties": false
+  }
+}

opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/apply_time_series.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+from opengeodeweb_microservice.schemas import Route, load_schema
+from dataclasses_json import DataClassJsonMixin
+from opengeodeweb_microservice.schemas import print_dataclass
+from dataclasses import dataclass
+
+
+@dataclass
+class ApplyTimeSeries(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    filename: str
+    id: str
+
+
+@dataclass
+class ApplyTimeSeriesResponse(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    pass
+
+
+apply_time_series_route = Route(
+    schema=load_schema(Path(__file__)),
+    params=ApplyTimeSeries,
+    response=ApplyTimeSeriesResponse,
+)
+
+__all__ = ["ApplyTimeSeries", "ApplyTimeSeriesResponse", "apply_time_series_route"]

opengeodeweb_back-6.15.3rc1/src/opengeodeweb_back/routes/schemas/missing_files.json → opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/data_missing_files.json

@@ -1,5 +1,5 @@
 {
-  "route": "/missing_files",
+  "route": "/data_missing_files",
   "methods": [
     "POST"
   ],
@@ -45,4 +45,4 @@
     ],
     "additionalProperties": false
   }
-}
+}

opengeodeweb_back-6.15.3rc1/src/opengeodeweb_back/routes/schemas/missing_files.py → opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/data_missing_files.py

@@ -7,7 +7,7 @@ from dataclasses import dataclass
 
 
 @dataclass
-class MissingFiles(DataClassJsonMixin):
+class DataMissingFiles(DataClassJsonMixin):
     def __post_init__(self) -> None:
         print_dataclass(self)
 
@@ -16,7 +16,7 @@ class MissingFiles(DataClassJsonMixin):
 
 
 @dataclass
-class MissingFilesResponse(DataClassJsonMixin):
+class DataMissingFilesResponse(DataClassJsonMixin):
     def __post_init__(self) -> None:
         print_dataclass(self)
 
@@ -25,10 +25,10 @@ class MissingFilesResponse(DataClassJsonMixin):
     mandatory_files: List[str]
 
 
-missing_files_route = Route(
+data_missing_files_route = Route(
     schema=load_schema(Path(__file__)),
-    params=MissingFiles,
-    response=MissingFilesResponse,
+    params=DataMissingFiles,
+    response=DataMissingFilesResponse,
 )
 
-__all__ = ["MissingFiles", "MissingFilesResponse", "missing_files_route"]
+__all__ = ["DataMissingFiles", "DataMissingFilesResponse", "data_missing_files_route"]

opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/time_series_allowed_objects.json

@@ -0,0 +1,32 @@
+{
+  "route": "/time_series_allowed_objects",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {
+    "filename": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": [
+    "filename"
+  ],
+  "additionalProperties": false,
+  "response": {
+    "type": "object",
+    "properties": {
+      "allowed_objects": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "required": [
+      "allowed_objects"
+    ],
+    "additionalProperties": false
+  }
+}

opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/time_series_allowed_objects.py

@@ -0,0 +1,31 @@
+from pathlib import Path
+from opengeodeweb_microservice.schemas import Route, load_schema
+from typing import List
+from dataclasses_json import DataClassJsonMixin
+from opengeodeweb_microservice.schemas import print_dataclass
+from dataclasses import dataclass
+
+
+@dataclass
+class TimeSeriesAllowedObjects(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    filename: str
+
+
+@dataclass
+class TimeSeriesAllowedObjectsResponse(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    allowed_objects: List[str]
+
+
+time_series_allowed_objects_route = Route(
+    schema=load_schema(Path(__file__)),
+    params=TimeSeriesAllowedObjects,
+    response=TimeSeriesAllowedObjectsResponse,
+)
+
+__all__ = ["TimeSeriesAllowedObjects", "TimeSeriesAllowedObjectsResponse", "time_series_allowed_objects_route"]

opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/time_series_missing_files.json

@@ -0,0 +1,43 @@
+{
+  "route": "/time_series_missing_files",
+  "methods": [
+    "POST"
+  ],
+  "type": "object",
+  "properties": {
+    "filename": {
+      "type": "string",
+      "minLength": 1
+    }
+  },
+  "required": [
+    "filename"
+  ],
+  "additionalProperties": false,
+  "response": {
+    "type": "object",
+    "properties": {
+      "has_missing_files": {
+        "type": "boolean"
+      },
+      "mandatory_files": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      },
+      "additional_files": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
+    "required": [
+      "has_missing_files",
+      "mandatory_files",
+      "additional_files"
+    ],
+    "additionalProperties": false
+  }
+}

opengeodeweb_back-6.16.0/src/opengeodeweb_back/routes/schemas/time_series_missing_files.py

@@ -0,0 +1,33 @@
+from pathlib import Path
+from opengeodeweb_microservice.schemas import Route, load_schema
+from typing import List
+from dataclasses_json import DataClassJsonMixin
+from opengeodeweb_microservice.schemas import print_dataclass
+from dataclasses import dataclass
+
+
+@dataclass
+class TimeSeriesMissingFiles(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    filename: str
+
+
+@dataclass
+class TimeSeriesMissingFilesResponse(DataClassJsonMixin):
+    def __post_init__(self) -> None:
+        print_dataclass(self)
+
+    additional_files: List[str]
+    has_missing_files: bool
+    mandatory_files: List[str]
+
+
+time_series_missing_files_route = Route(
+    schema=load_schema(Path(__file__)),
+    params=TimeSeriesMissingFiles,
+    response=TimeSeriesMissingFilesResponse,
+)
+
+__all__ = ["TimeSeriesMissingFiles", "TimeSeriesMissingFilesResponse", "time_series_missing_files_route"]

{opengeodeweb_back-6.15.3rc1 → opengeodeweb_back-6.16.0}/tests/test_routes.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 # Standard library imports
 import json
 import os
+import shutil
 import sqlite3
 import zipfile
 from pathlib import Path
@@ -50,10 +51,13 @@ def test_allowed_files(client: FlaskClient) -> None:
     json = get_full_data()
     response = client.post(route, json=json)
     assert response.status_code == 200
-    extensions = response.get_json()["extensions"]
+    extensions = response.get_json()["data_extensions"]
     assert type(extensions) is list
     for extension in extensions:
         assert type(extension) is str
+    time_series_extensions = response.get_json()["time_series_extensions"]
+    assert "pvd" in time_series_extensions
+    assert "pvd" not in extensions
 
     # Test all params
     test_utils.test_route_wrong_params(client, route, get_full_data)
@@ -166,8 +170,8 @@ def test_upload_file_chunked_invalid_chunk_index(client: FlaskClient) -> None:
     assert response.status_code == 400
 
 
-def test_missing_files(client: FlaskClient) -> None:
-    route = "/opengeodeweb_back/missing_files"
+def test_data_missing_files(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/data_missing_files"
 
     def get_full_data() -> test_utils.JsonData:
         return {
@@ -886,3 +890,113 @@ def test_vertex_attribute_names_time_series(client: FlaskClient) -> None:
     ]
     assert len(temperature) == 1
     assert temperature[0]["time_steps"] == [0.5, 1.0, 2.0]
+
+
+def test_upload_file_relative_path(client: FlaskClient) -> None:
+    upload_folder = Path(client.application.config["UPLOAD_FOLDER_PATH"]).resolve()
+    try:
+        for filename, expected in [
+            ("nested_upload/sub/file.txt", upload_folder / "nested_upload/sub/file.txt"),
+            ("../nested_upload/escape.txt", upload_folder / "nested_upload/escape.txt"),
+        ]:
+            response = client.put(
+                "/opengeodeweb_back/upload_file",
+                query_string={"filename": filename},
+                data=b"content",
+            )
+            assert response.status_code == 201
+            assert expected.is_file()
+    finally:
+        shutil.rmtree(upload_folder / "nested_upload", ignore_errors=True)
+
+
+def test_time_series_missing_files(client: FlaskClient) -> None:
+    upload_folder = Path(client.application.config["UPLOAD_FOLDER_PATH"]).resolve()
+    try:
+        response = client.put(
+            "/opengeodeweb_back/upload_file",
+            query_string={"filename": "lonely_time_series/time_series.pvd"},
+            data=(data_dir / "time_series" / "time_series.pvd").read_bytes(),
+        )
+        assert response.status_code == 201
+        response = client.post(
+            "/opengeodeweb_back/time_series_missing_files",
+            json={"filename": "lonely_time_series/time_series.pvd"},
+        )
+        assert response.status_code == 200
+        assert response.get_json()["has_missing_files"] is True
+        assert "vtkOutput/000000.vtm" in response.get_json()["mandatory_files"]
+    finally:
+        shutil.rmtree(upload_folder / "lonely_time_series", ignore_errors=True)
+
+
+def test_time_series_missing_files_outside_folder(client: FlaskClient) -> None:
+    upload_folder = Path(client.application.config["UPLOAD_FOLDER_PATH"]).resolve()
+    pvd = (
+        '<?xml version="1.0"?>\n<VTKFile type="Collection" version="0.1"><Collection>'
+        '<DataSet timestep="0" file="../000000.vtm" /></Collection></VTKFile>\n'
+    )
+    try:
+        response = client.put(
+            "/opengeodeweb_back/upload_file",
+            query_string={"filename": "outside_time_series/sub/time_series.pvd"},
+            data=pvd.encode(),
+        )
+        assert response.status_code == 201
+        response = client.post(
+            "/opengeodeweb_back/time_series_missing_files",
+            json={"filename": "outside_time_series/sub/time_series.pvd"},
+        )
+        assert response.status_code == 400
+    finally:
+        shutil.rmtree(upload_folder / "outside_time_series", ignore_errors=True)
+
+
+def test_time_series_allowed_objects(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/time_series_allowed_objects"
+
+    def get_full_data() -> test_utils.JsonData:
+        return {"filename": "time_series/time_series.pvd"}
+
+    response = client.post(route, json=get_full_data())
+    assert response.status_code == 200
+    allowed_objects = response.get_json()["allowed_objects"]
+    assert allowed_objects == ["BRep"]
+
+    test_utils.test_route_wrong_params(client, route, get_full_data)
+
+
+def test_apply_time_series(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/apply_time_series"
+    model_id, by_type = _load_brep_components(client)
+
+    def get_full_data() -> test_utils.JsonData:
+        return {"id": model_id, "filename": "time_series/time_series.pvd"}
+
+    response = client.post(route, json=get_full_data())
+    assert response.status_code == 200
+
+    response = client.post(
+        "/opengeodeweb_back/model_component_polyhedron_attribute_names",
+        json={"id": model_id, "component_ids": by_type["Block"]},
+    )
+    pressure = [
+        attribute
+        for attribute in response.get_json()["attributes"]
+        if attribute["attribute_name"] == "pressure"
+    ]
+    assert len(pressure) == 1
+    assert pressure[0]["time_steps"] == [0.0, 1.0]
+
+    test_utils.test_route_wrong_params(client, route, get_full_data)
+
+
+def test_apply_time_series_errors(client: FlaskClient) -> None:
+    route = "/opengeodeweb_back/apply_time_series"
+    filename = "time_series/time_series.pvd"
+    response = client.post(route, json={"id": "0" * 32, "filename": filename})
+    assert response.status_code == 404
+
+    point_set_id = check_save_viewable_file(client, "PointSet3D", "test.og_pts3d").get_json()["id"]
+    response = client.post(route, json={"id": point_set_id, "filename": filename})
+    assert response.status_code == 400