fix(links): endpoint links create

antarest/core/exceptions.py

@@ -295,6 +295,11 @@ def __init__(self, message: str) -> None:
         super().__init__(HTTPStatus.UNPROCESSABLE_ENTITY, message)
 
 
+class LinkValidationError(HTTPException):
+    def __init__(self, message: str) -> None:
+        super().__init__(HTTPStatus.UNPROCESSABLE_ENTITY, message)
+
+
 class VariantStudyParentNotValid(HTTPException):
     def __init__(self, message: str) -> None:
         super().__init__(HTTPStatus.UNPROCESSABLE_ENTITY, message)

antarest/core/utils/string.py

@@ -18,3 +18,7 @@ def to_pascal_case(value: str) -> str:
 def to_camel_case(value: str) -> str:
     v = to_pascal_case(value)
     return v[0].lower() + v[1:] if len(v) > 0 else ""
+
+
+def to_kebab_case(string: str) -> str:
+    return string.replace("_", "-")

antarest/study/business/link_management.py

@@ -12,31 +12,38 @@
 
 import typing as t
 
-from antarest.core.exceptions import ConfigFileNotFound
+from antares.study.version import StudyVersion
+from pydantic import ConfigDict
+
+from antarest.core.exceptions import ConfigFileNotFound, LinkValidationError
 from antarest.core.model import JSON
-from antarest.core.serialization import AntaresBaseModel
+from antarest.core.utils.string import to_camel_case
 from antarest.study.business.all_optional_meta import all_optional_model, camel_case_model
 from antarest.study.business.utils import execute_or_add_commands
-from antarest.study.model import RawStudy
+from antarest.study.model import STUDY_VERSION_8_2, RawStudy
 from antarest.study.storage.rawstudy.model.filesystem.config.links import LinkProperties
 from antarest.study.storage.storage_service import StudyStorageService
-from antarest.study.storage.variantstudy.model.command.create_link import CreateLink
+from antarest.study.storage.variantstudy.model.command.create_link import (
+    AreaInfo,
+    CreateLink,
+    LinkInfoProperties,
+    LinkInfoProperties820,
+)
 from antarest.study.storage.variantstudy.model.command.remove_link import RemoveLink
 from antarest.study.storage.variantstudy.model.command.update_config import UpdateConfig
 
 _ALL_LINKS_PATH = "input/links"
 
 
-class LinkUIDTO(AntaresBaseModel):
-    color: str
-    width: float
-    style: str
+class LinkInfoDTOBase(AreaInfo, LinkInfoProperties):
+    model_config = ConfigDict(alias_generator=to_camel_case, populate_by_name=True, extra="forbid")
+
 
+class LinkInfoDTO820(AreaInfo, LinkInfoProperties820):
+    model_config = ConfigDict(alias_generator=to_camel_case, populate_by_name=True, extra="forbid")
 
-class LinkInfoDTO(AntaresBaseModel):
-    area1: str
-    area2: str
-    ui: t.Optional[LinkUIDTO] = None
+
+LinkInfoDTO = t.Union[LinkInfoDTO820, LinkInfoDTOBase]
 
 
 @all_optional_model
@@ -51,38 +58,57 @@ class LinkManager:
     def __init__(self, storage_service: StudyStorageService) -> None:
         self.storage_service = storage_service
 
-    def get_all_links(self, study: RawStudy, with_ui: bool = False) -> t.List[LinkInfoDTO]:
+    def get_all_links(self, study: RawStudy) -> t.List[LinkInfoDTO]:
         file_study = self.storage_service.get_storage(study).get_raw(study)
-        result = []
+        result: t.List[LinkInfoDTO] = []
+
         for area_id, area in file_study.config.areas.items():
-            links_config: t.Optional[t.Dict[str, t.Any]] = None
-            if with_ui:
-                links_config = file_study.tree.get(["input", "links", area_id, "properties"])
+            links_config = file_study.tree.get(["input", "links", area_id, "properties"])
+
             for link in area.links:
-                ui_info: t.Optional[LinkUIDTO] = None
-                if with_ui and links_config and link in links_config:
-                    ui_info = LinkUIDTO(
-                        color=f"{links_config[link].get('colorr', '163')},{links_config[link].get('colorg', '163')},{links_config[link].get('colorb', '163')}",
-                        width=links_config[link].get("link-width", 1),
-                        style=links_config[link].get("link-style", "plain"),
-                    )
-                result.append(LinkInfoDTO(area1=area_id, area2=link, ui=ui_info))
+                link_tree_config: t.Dict[str, t.Any] = links_config[link]
+                link_tree_config.update({"area1": area_id, "area2": link})
+
+                link_properties = {"area1": area_id, "area2": link}
+                link_dto: LinkInfoDTO
+                if StudyVersion.parse(study.version) < STUDY_VERSION_8_2:
+                    link_properties.update(LinkInfoProperties(**link_tree_config).model_dump())
+                    link_dto = LinkInfoDTOBase(**link_properties)
+                else:
+                    link_properties.update(LinkInfoProperties820(**link_tree_config).model_dump())
+                    link_dto = LinkInfoDTO820(**link_properties)
+
+                result.append(link_dto)
 
         return result
 
     def create_link(self, study: RawStudy, link_creation_info: LinkInfoDTO) -> LinkInfoDTO:
+        if link_creation_info.area1 == link_creation_info.area2:
+            raise LinkValidationError(f"Cannot create link on same area: {link_creation_info.area1}")
+
+        link_dto: LinkInfoDTO
+        if StudyVersion.parse(study.version) >= STUDY_VERSION_8_2:
+            link_dto = LinkInfoDTO820.model_validate(link_creation_info.model_dump())
+        else:
+            forbidden_fields = {"filter_synthesis", "filter_year_by_year"}
+            fields = set(link_creation_info.model_dump(exclude_defaults=True))
+            if forbidden_fields & fields:
+                raise LinkValidationError("Cannot specify a filter value for study's version earlier than v8.2")
+            link_dto = LinkInfoDTOBase.model_validate(link_creation_info.model_dump(exclude=forbidden_fields))
+
         storage_service = self.storage_service.get_storage(study)
         file_study = storage_service.get_raw(study)
+
         command = CreateLink(
             area1=link_creation_info.area1,
             area2=link_creation_info.area2,
+            parameters=link_dto.model_dump(exclude_none=True),
             command_context=self.storage_service.variant_study_service.command_factory.command_context,
         )
+
         execute_or_add_commands(study, file_study, [command], self.storage_service)
-        return LinkInfoDTO(
-            area1=link_creation_info.area1,
-            area2=link_creation_info.area2,
-        )
+
+        return link_dto
 
     def delete_link(self, study: RawStudy, area1_id: str, area2_id: str) -> None:
         file_study = self.storage_service.get_storage(study).get_raw(study)

antarest/study/business/table_mode_management.py

@@ -98,8 +98,9 @@ def _get_table_data_unsafe(self, study: RawStudy, table_type: TableModeType) ->
             data = {area_id: area.model_dump(mode="json", by_alias=True) for area_id, area in areas_map.items()}
         elif table_type == TableModeType.LINK:
             links_map = self._link_manager.get_all_links_props(study)
+            excludes = set() if int(study.version) >= 820 else {"filter_synthesis", "filter_year_by_year"}
             data = {
-                f"{area1_id} / {area2_id}": link.model_dump(mode="json", by_alias=True)
+                f"{area1_id} / {area2_id}": link.model_dump(mode="json", by_alias=True, exclude=excludes)
                 for (area1_id, area2_id), link in links_map.items()
             }
         elif table_type == TableModeType.THERMAL:
@@ -195,8 +196,9 @@ def update_table_data(
         elif table_type == TableModeType.LINK:
             links_map = {tuple(key.split(" / ")): LinkOutput(**values) for key, values in data.items()}
             updated_map = self._link_manager.update_links_props(study, links_map)  # type: ignore
+            excludes = set() if int(study.version) >= 820 else {"filter_synthesis", "filter_year_by_year"}
             data = {
-                f"{area1_id} / {area2_id}": link.model_dump(by_alias=True)
+                f"{area1_id} / {area2_id}": link.model_dump(by_alias=True, exclude=excludes)
                 for (area1_id, area2_id), link in updated_map.items()
             }
             return data

antarest/study/service.py

@@ -85,7 +85,7 @@
 from antarest.study.business.correlation_management import CorrelationManager
 from antarest.study.business.district_manager import DistrictManager
 from antarest.study.business.general_management import GeneralManager
-from antarest.study.business.link_management import LinkInfoDTO, LinkManager
+from antarest.study.business.link_management import LinkInfoDTO, LinkManager, LinkOutput
 from antarest.study.business.matrix_management import MatrixManager, MatrixManagerError
 from antarest.study.business.optimization_management import OptimizationManager
 from antarest.study.business.playlist_management import PlaylistManager
@@ -1857,12 +1857,11 @@ def get_all_areas(
     def get_all_links(
         self,
         uuid: str,
-        with_ui: bool,
         params: RequestParameters,
     ) -> t.List[LinkInfoDTO]:
         study = self.get_study(uuid)
         assert_permission(params.user, study, StudyPermissionType.READ)
-        return self.links.get_all_links(study, with_ui)
+        return self.links.get_all_links(study)
 
     def create_area(
         self,

antarest/study/storage/rawstudy/model/filesystem/config/links.py

@@ -66,6 +66,43 @@ class TransmissionCapacity(EnumIgnoreCase):
     ENABLED = "enabled"
 
 
+class LinkStyle(EnumIgnoreCase):
+    """
+    Enum representing the style of a link in a network visualization.
+
+    Attributes:
+        DOT: Represents a dotted line style.
+        PLAIN: Represents a solid line style.
+        DASH: Represents a dashed line style.
+        DOT_DASH: Represents a line style with alternating dots and dashes.
+    """
+
+    DOT = "dot"
+    PLAIN = "plain"
+    DASH = "dash"
+    DOT_DASH = "dotdash"
+    OTHER = "other"
+
+
+class FilterOption(EnumIgnoreCase):
+    """
+    Enum representing the time filter options for data visualization or analysis in Antares Web.
+
+    Attributes:
+        HOURLY: Represents filtering data by the hour.
+        DAILY: Represents filtering data by the day.
+        WEEKLY: Represents filtering data by the week.
+        MONTHLY: Represents filtering data by the month.
+        ANNUAL: Represents filtering data by the year.
+    """
+
+    HOURLY = "hourly"
+    DAILY = "daily"
+    WEEKLY = "weekly"
+    MONTHLY = "monthly"
+    ANNUAL = "annual"
+
+
 class LinkProperties(IniProperties):
     """
     Configuration read from a section in the `input/links/<area1>/properties.ini` file.
@@ -159,11 +196,12 @@ def _validate_colors(cls, values: t.MutableMapping[str, t.Any]) -> t.Mapping[str
         return validate_colors(values)
 
     # noinspection SpellCheckingInspection
-    def to_config(self) -> t.Dict[str, t.Any]:
+    def to_ini(self, version: int) -> t.Dict[str, t.Any]:
         """
         Convert the object to a dictionary for writing to a configuration file.
         """
-        obj = dict(super().to_config())
+        excludes = set() if version >= 820 else {"filter_synthesis", "filter_year_by_year"}
+        obj = self.model_dump(mode="json", exclude_none=True, by_alias=True, exclude=excludes)
         color_rgb = obj.pop("colorRgb", "#707070")
         return {
             "colorr": int(color_rgb[1:3], 16),