conflicts resolution before merge

src/Model/BoundaryCondition/BoundaryCondition.py

@@ -329,7 +329,8 @@ class BoundaryCondition(SQLSubModel):
             return new
 
         table = execute(
-            "SELECT pamhyr_id, deleted, name, type, node, d50, sigma, scenario " +
+            "SELECT pamhyr_id, deleted, name, type, node, d50, sigma, " +
+            "scenario " +
             "FROM boundary_condition " +
             f"WHERE tab = '{tab}' " +
             f"AND scenario = {scenario.id} " +
@@ -355,11 +356,14 @@ class BoundaryCondition(SQLSubModel):
                 status=data['status'],
                 owner_scenario=owner_scenario
             )
+
             if deleted:
                 bc.set_as_deleted()
-            if t=="SL":
+
+            if t == "SL":
                 bc.d50 = d50
                 bc.sigma = sigma
+
             bc.node = None
             if node != -1:
                 bc.node = next(filter(lambda n: n.id == node, nodes), None)
@@ -510,6 +514,42 @@ class BoundaryCondition(SQLSubModel):
         self._sigma = float(value)
         self.modified()
 
+    @property
+    def d50(self):
+        return self._d50
+
+    @d50.setter
+    def d50(self, value):
+        self._d50 = float(value)
+        self.modified()
+
+    @property
+    def sigma(self):
+        return self._sigma
+
+    @sigma.setter
+    def sigma(self, value):
+        self._sigma = float(value)
+        self.modified()
+
+    @property
+    def d50(self):
+        return self._d50
+
+    @d50.setter
+    def d50(self, value):
+        self._d50 = float(value)
+        self.modified()
+
+    @property
+    def sigma(self):
+        return self._sigma
+
+    @sigma.setter
+    def sigma(self, value):
+        self._sigma = float(value)
+        self.modified()
+
     @property
     def header(self):
         return self._header.copy()

src/Model/BoundaryConditionsAdisTS/BoundaryConditionAdisTS.py

@@ -144,6 +144,7 @@ class Data(SQLSubModel):
             "SELECT pamhyr_id, deleted, data0, data1, scenario FROM " +
             "boundary_condition_data_adists " +
             f"WHERE bca = {bca.id} " +
+            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) " +
             f"AND scenario = {scenario.id}"
         )
 
@@ -300,6 +301,12 @@ class BoundaryConditionAdisTS(SQLSubModel):
             if pol_id == -1:
                 continue
 
+            if pol_id not in pid_pol:
+                # ⚠️ cas important : probablement déjà migré
+                print(f"[WARN] pol_id {pol_id} not in pid_pol " +
+                      f"→ probably already migrated")
+                continue
+
             execute(
                 f"UPDATE boundary_condition_adists " +
                 f"SET pollutant = {pid_pol[pol_id]} " +

src/Model/LateralContributionsAdisTS/LateralContributionAdisTS.py

@@ -132,11 +132,13 @@ class Data(SQLSubModel):
         if scenario is None:
             return new
 
+        lca = data["lca"]
+
         table = execute(
-            "SELECT pamhyr_id, deleted, data0, data1 " +
+            "SELECT pamhyr_id, deleted, data0, data1, scenario " +
             "FROM lateral_contribution_data_adists " +
             f"WHERE scenario = {scenario.id} " +
-            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) "
+            f"AND pamhyr_id NOT IN ({', '.join(map(str, loaded))}) " +
             f"AND lca = '{lca.id}'"
         )
 
@@ -150,16 +152,16 @@ class Data(SQLSubModel):
                 data1 = next(it)
                 owner_scenario = next(it)
 
-                data = cls(
+                lc = cls(
                     data0, data1,
                     id=pid, status=status,
                     owner_scenario=owner_scenario
                 )
                 if deleted:
-                    data.set_as_deleted()
+                    lc.set_as_deleted()
 
                 loaded.add(pid)
-                new.append(data)
+                new.append(lc)
 
         data["scenario"] = scenario.parent
         new += cls._db_load(execute, data)
@@ -175,7 +177,7 @@ class Data(SQLSubModel):
 
         execute(
             "INSERT INTO " +
-            "lateral_contribution_adists(pamhyr_id, deleted," +
+            "lateral_contribution_data_adists(pamhyr_id, deleted," +
             "data0, data1, lca, scenario) " +
             "VALUES (" +
             f"{self.id}, {self._db_format(self.is_deleted())}, " +
@@ -372,16 +374,18 @@ class LateralContributionAdisTS(SQLSubModel):
 
         execute(
             "INSERT INTO " +
-            "lateral_contribution_adists(pamhyr_id, deleted," +
+            "lateral_contribution_adists(pamhyr_id, deleted, " +
             "pollutant, reach, begin_rk, end_rk, scenario) " +
             "VALUES (" +
             f"{self.id}, {self._db_format(self.is_deleted())}, " +
             f"{self._pollutant}, {self.reach}, " +
-            f"{self._begin_rk}, {self._end_rk}" +
+            f"{self._begin_rk}, {self._end_rk}, " +
             f"{self._status.scenario_id}" +
             ")"
         )
 
+        data["lca"] = self
+
         ind = 0
         for d in self._data:
             data["ind"] = ind
@@ -471,3 +475,57 @@ class LateralContributionAdisTS(SQLSubModel):
     def end_rk(self, end_rk):
         self._end_rk = end_rk
         self.modified()
+
+    @property
+    def _default_0(self):
+        return self._types[0](0)
+
+    @property
+    def _default_1(self):
+        return self._types[1](0.0)
+
+    def add(self, index: int):
+        value = Data(self._default_0, self._default_1, status=self._status)
+        self._data.insert(index, value)
+        self.modified()
+        return value
+
+    def insert(self, index: int, data: Data):
+        self._data.insert(index, data)
+        self.modified()
+
+    def delete_i(self, indexes):
+        self._data = list(
+            map(
+                lambda e: e[1],
+                filter(
+                    lambda e: e[0] not in indexes,
+                    enumerate(self.data)
+                )
+            )
+        )
+        self.modified()
+
+    def index(self, bc):
+        self._data.index(bc)
+
+    def get_i(self, index: int):
+        return self._data[index]
+
+    def get_range(self, _range):
+        lst = []
+        for r in _range:
+            lst.append(r)
+        return lst
+
+    def _set_i_c_v(self, index: int, column: int, value):
+        v = self._data[index]
+        v[column] = self._types[column](value)
+        self._data[index] = v
+        self.modified()
+
+    def set_i_0(self, index: int, value):
+        self._set_i_c_v(index, 0, value)
+
+    def set_i_1(self, index: int, value):
+        self._set_i_c_v(index, 1, value)

src/Model/Pollutants/Pollutants.py

@@ -28,7 +28,9 @@ from tools import (
 from Model.Tools.PamhyrDB import SQLSubModel
 from Model.Except import NotImplementedMethodeError
 from Model.Scenario import Scenario
-from Model.BoundaryConditionsAdisTS.BoundaryConditionAdisTS import BoundaryConditionAdisTS
+from Model.BoundaryConditionsAdisTS.BoundaryConditionAdisTS import (
+    BoundaryConditionAdisTS,
+)
 
 logger = logging.getLogger()
 
@@ -427,6 +429,13 @@ class Pollutants(SQLSubModel):
                     execute, data=data
                 )
 
+                new_pollutant._boundary_conditions_adists = (
+                    BoundaryConditionAdisTS._db_load(
+                        execute,
+                        data=data
+                    )
+                )
+
                 loaded.add(pid)
                 new.append(new_pollutant)
 

src/Model/Tools/PamhyrDB.py

@@ -311,6 +311,12 @@ class SQLSubModel(PamhyrID):
             if node_id == -1:
                 continue
 
+            if node_id not in nodes:
+                # ⚠️ cas important : probablement déjà migré
+                print(f"[WARN] node_id {node_id} not in nodes " +
+                      f"→ probably already migrated")
+                continue
+
             execute(
                 f"UPDATE {table} " +
                 f"SET node = {nodes[node_id]} " +

src/View/BoundaryConditionsAdisTS/Edit/Window.py

@@ -63,6 +63,16 @@ class EditBoundaryConditionWindow(PamhyrWindow):
 
         name = trad[self._pamhyr_name]
 
+        if self._data is not None:
+            n = self._data.node
+            node_name = next(filter(
+                lambda x: x.id == n, study.river._nodes
+            )).name
+            name += (
+                f" - {study.name} " +
+                f"({node_name})"
+            )
+
         super(EditBoundaryConditionWindow, self).__init__(
             title=name,
             study=study,
@@ -71,16 +81,6 @@ class EditBoundaryConditionWindow(PamhyrWindow):
             parent=parent
         )
 
-        if self._data is not None:
-            n = self._data.node
-            node_name = next(filter(
-                lambda x: x.id == n, self._study.river._nodes
-            )).name
-            name += (
-                f" - {study.name} " +
-                f"({node_name})"
-            )
-
         self._hash_data.append(data)
 
         self.setup_table()

src/View/BoundaryConditionsAdisTS/Table.py

@@ -112,7 +112,8 @@ class ComboBoxDelegate(QItemDelegate):
 
 
 class TableModel(PamhyrTableModel):
-    def __init__(self, bc_list=None, pollutant_bc_list=None, trad=None, **kwargs):
+    def __init__(self, bc_list=None, pollutant_bc_list=None,
+                 trad=None, **kwargs):
         self._trad = trad
         self._bc_list = bc_list
         self._pollutant = pollutant_bc_list.id
@@ -214,9 +215,14 @@ class TableModel(PamhyrTableModel):
     def delete(self, rows, parent=QModelIndex()):
         self.beginRemoveRows(parent, rows[0], rows[-1])
 
-        global_rows = list(
+        row_by_bc = {
-            map(self._global_row, rows)
+            id(bc): row for row, bc in enumerate(self._bc_list._lst)
-        )
+        }
+        global_rows = [
+            row_by_bc[id(self._lst[row])]
+            for row in rows
+            if 0 <= row < len(self._lst)
+        ]
         self._undo.push(
             DelCommand(
                 self._bc_list, global_rows

src/View/BoundaryConditionsAdisTS/Window.py

@@ -58,17 +58,18 @@ class BoundaryConditionAdisTSWindow(PamhyrWindow):
     _pamhyr_ui = "BoundaryConditionsAdisTS"
     _pamhyr_name = "Boundary conditions AdisTS"
 
-    def __init__(self, data=None, pollutant_id=None, study=None, config=None, parent=None):
+    def __init__(self, data=None, pollutant_id=None, study=None,
+                 config=None, parent=None):
         self._data = data
         self._pollutant_id = pollutant_id
+        trad = BCAdisTSTranslate()
 
-        _pollutants_lst = study._river._Pollutants.Pollutants_List
         self._pollutant_name = next(
-            (x.name for x in _pollutants_lst if x.id == self._pollutant_id),
+            (x.name for x in study._river._Pollutants.Pollutants_List
+             if x.id == self._pollutant_id),
             None
         )
 
-        trad = BCAdisTSTranslate()
         name = (
             trad[self._pamhyr_name] +
             " - " + study.name +

src/View/D90AdisTS/Table.py

@@ -120,7 +120,7 @@ class D90TableModel(PamhyrTableModel):
     def _setup_lst(self):
         self._lst = list(
             filter(
-                lambda d90: d90._deleted == False,
+                lambda d90: d90._deleted is False,
                 self._data._data
             )
         )

src/View/Geometry/ShiftDialog.py

@@ -19,6 +19,9 @@
 from View.Tools.PamhyrWindow import PamhyrDialog
 from PyQt5.QtWidgets import QDoubleSpinBox
 from View.Tools.FlexibleDoubleSpinBox import FlexibleDoubleSpinBox
+from PyQt5.QtWidgets import QDoubleSpinBox
+from View.Tools.FlexibleDoubleSpinBox import FlexibleDoubleSpinBox
+
 
 class ShiftDialog(PamhyrDialog):
     _pamhyr_ui = "GeometryReachShift"

src/View/Geometry/Translate.py

@@ -91,3 +91,9 @@ class GeometryTranslate(MainTranslate):
         self._dict["Shift"] = _translate(
             "Geometry", "Shift"
         )
+        self._dict["warning"] = _translate(
+            "Geometry", "Warning"
+        )
+        self._dict["format_not_exportable"] = _translate(
+            "Geometry", "The format of the file is not exportable."
+        )

src/View/Geometry/Window.py

@@ -691,7 +691,13 @@ class GeometryWindow(PamhyrWindow):
                 if suffix == ".st" or suffix == ".ST":
                     self._export_to_file_st(filename[:-3])
                 else:
-                    # TODO : prévenir l'utilisateur que le format n'est pas exportable
+                    # Warning popup when the format is not exportable
+                    win = QtWidgets.QMessageBox()
+                    win.setIcon(QtWidgets.QMessageBox.Warning)
+                    win.setWindowTitle(self._trad["warning"])
+                    win.setText(self._trad["format_not_exportable"])
+                    win.exec()
+
                     pass
             else:
                 self._export_to_file_st(filename)

src/View/InitialConditionsAdisTS/Table.py

@@ -119,7 +119,7 @@ class InitialConditionTableModel(PamhyrTableModel):
     def _setup_lst(self):
         self._lst = list(
             filter(
-                lambda ica: ica._deleted == False,
+                lambda ica: ica._deleted is False,
                 self._data._data
             )
         )

src/View/InitialConditionsAdisTS/Window.py

@@ -68,15 +68,22 @@ class InitialConditionsAdisTSWindow(PamhyrWindow):
     _pamhyr_ui = "InitialConditionsAdisTS"
     _pamhyr_name = "Initial condition AdisTS"
 
-    def __init__(self, data=None, study=None, config=None, parent=None):
+    def __init__(self, data=None, pollutant_id=None, study=None,
+                 config=None, parent=None):
         self._data = []
         self._data.append(data)
+        self._pollutant_id = pollutant_id
         trad = IcAdisTSTranslate()
 
+        self._pollutant_name = next(
+            (x.name for x in study._river._Pollutants.Pollutants_List
+             if x.id == self._pollutant_id),
+            None
+        )
         name = (
             trad[self._pamhyr_name] +
             " - " + study.name +
-            " - " + self._data[0].name
+            " - " + self._pollutant_name
         )
 
         super(InitialConditionsAdisTSWindow, self).__init__(

src/View/LateralContributionsAdisTS/Edit/UndoCommand.py

@@ -34,29 +34,14 @@ class SetDataCommand(QUndoCommand):
         self._data = data
         self._index = index
         self._column = column
-        self._old = self._data._data[self._index][self._column]
+        self._old = self._data.get_i(self._index)[self._column]
-        _type = self._data._types[self._column]
+        self._new = new_value
-        self._new = _type(new_value)
 
     def undo(self):
-        if self._column == 0:
+        self._data._set_i_c_v(self._index, self._column, self._old)
-            self._data._data[self._index] = (
-                self._old, self._data._data[self._index][1]
-            )
-        else:
-            self._data._data[self._index] = (
-                self._data._data[self._index][0], self._old
-            )
 
     def redo(self):
-        if self._column == 0:
+        self._data._set_i_c_v(self._index, self._column, self._new)
-            self._data._data[self._index] = (
-                self._new, self._data._data[self._index][1]
-            )
-        else:
-            self._data._data[self._index] = (
-                self._data._data[self._index][0], self._new
-            )
 
 
 class AddCommand(QUndoCommand):
@@ -72,11 +57,7 @@ class AddCommand(QUndoCommand):
 
     def redo(self):
         if self._new is None:
-            self._new = self._data._data.insert(
+            self._new = self._data.add(self._index)
-                self._index, (
-                    self._data._types[0](0), self._data._types[1](0.0)
-                )
-            )
         else:
             self._data._data.insert(self._index, self._new)
 

src/View/LateralContributionsAdisTS/Edit/Window.py

@@ -50,14 +50,38 @@ class EditLateralContributionAdisTSWindow(PamhyrWindow):
     _pamhyr_ui = "EditLateralContributionAdisTS"
     _pamhyr_name = "Edit lateral contribution AdisTS"
 
-    def __init__(self, data=None,
+    def __init__(self, data=None, study=None, config=None, parent=None):
-                 study=None, config=None,
-                 parent=None):
         self._data = data
-
         trad = LCETranslate()
+
         name = trad[self._pamhyr_name]
 
+        if self._data is not None:
+            if self._data.reach is not None:
+                reach_name = next(filter(
+                    lambda reach: reach.id == self._data.reach,
+                    study.river.reachs()
+                )).name
+            else:
+                reach_name = trad['not_associated']
+
+            if self._data.begin_rk is not None:
+                begin_rk = self._data.begin_rk
+            else:
+                begin_rk = trad['not_associated']
+
+            if self._data.end_rk is not None:
+                end_rk = self._data.end_rk
+            else:
+                end_rk = trad['not_associated']
+
+            name += (
+                f" - {study.name} - " +
+                f"{reach_name} - " +
+                f"({begin_rk} - " +
+                f"{end_rk})"
+            )
+
         super(EditLateralContributionAdisTSWindow, self).__init__(
             title=name,
             study=study,
@@ -66,20 +90,6 @@ class EditLateralContributionAdisTSWindow(PamhyrWindow):
             parent=parent
         )
 
-        if self._data is not None:
-            if self._data.edge is not None:
-                edge_name = next(filter(
-                    lambda edge: edge.id == self._data.edge,
-                    self._study.river.edges()
-                )).name
-            else:
-                edge_name = trad['not_associated']
-
-            name += (
-                f"{study.name} - " +
-                f"{edge_name})"
-            )
-
         self._hash_data.append(data)
 
         self.setup_table()

src/View/LateralContributionsAdisTS/Table.py

@@ -116,10 +116,22 @@ class TableModel(PamhyrTableModel):
         self._pollutant = pollutant
 
         super(TableModel, self).__init__(trad=trad, **kwargs)
+        self._setup_lst()
 
     def _setup_lst(self):
-        self._lst = self._data.lateral_contributions_adists.lst
+        if self._lcs_list is not None:
-        self._tab = self._opt_data
+            self._lcs_pol_list = [
+                lcs for lcs in self._lcs_list._lst
+                if lcs.pollutant == self._pollutant
+            ]
+
+        self._lst = list(
+            filter(
+                lambda x: x._deleted is False,
+                self._lcs_pol_list
+            )
+        )
+        # self._tab = self._opt_data
         self._long_types = self._trad.get_dict("long_types")
 
     def rowCount(self, parent):
@@ -190,17 +202,37 @@ class TableModel(PamhyrTableModel):
             )
         )
 
+        self._setup_lst()
         self.endInsertRows()
         self.layoutChanged.emit()
 
     def delete(self, rows, parent=QModelIndex()):
         self.beginRemoveRows(parent, rows[0], rows[-1])
 
+        row_by_lc = {
+            id(lc): row for row, lc in enumerate(self._lcs_list._lst)
+        }
+        global_rows = [
+            row_by_lc[id(self._lst[row])]
+            for row in rows
+            if 0 <= row < len(self._lst)
+        ]
         self._undo.push(
             DelCommand(
-                self._lst, rows
+                self._lcs_list, global_rows
             )
         )
 
+        self._setup_lst()
         self.endRemoveRows()
         self.layoutChanged.emit()
+
+    def undo(self):
+        self._undo.undo()
+        self._setup_lst()
+        self.layoutChanged.emit()
+
+    def redo(self):
+        self._undo.redo()
+        self._setup_lst()
+        self.layoutChanged.emit()

src/View/LateralContributionsAdisTS/UndoCommand.py

@@ -91,13 +91,13 @@ class AddCommand(QUndoCommand):
         self._new = None
 
     def undo(self):
-        del self._lcs[self._index]
+        self._lcs.delete_i(self._index)
 
     def redo(self):
         if self._new is None:
             self._new = self._lcs.new(self._index, self._pollutant)
         else:
-            self._lcs_lst.insert(self._index, self._new)
+            self._lcs.insert(self._index, self._new)
 
 
 class DelCommand(QUndoCommand):
@@ -107,15 +107,14 @@ class DelCommand(QUndoCommand):
         self._lcs = lcs
         self._rows = rows
 
-        self._bc = []
+        self._lc = []
         for row in rows:
-            self._bc.append((row, self._lcs[row]))
+            self._lc.append((row, self._lcs._lst[row]))
-        self._bc.sort()
+        self._lc.sort()
 
     def undo(self):
-        for row, el in self._bc:
+        for row, el in self._lc:
             self._lcs.insert(row, el)
 
     def redo(self):
-        for row in self._rows:
+        self._lcs.delete_i(self._rows)
-            del self._lcs[row]

src/View/LateralContributionsAdisTS/Window.py

@@ -57,11 +57,24 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
     _pamhyr_ui = "LateralContributionsAdisTS"
     _pamhyr_name = "Lateral contribution AdisTS"
 
-    def __init__(self, study=None, pollutant=None, config=None, parent=None):
+    def __init__(self, data=None, study=None, pollutant_id=None,
+                 config=None, parent=None):
+        self._pollutant = pollutant_id
+        self._study = study
+        self._data = data
         trad = LCTranslate()
-        name = trad[self._pamhyr_name] + " - " + study.name
 
-        self._pollutant = pollutant
+        self._pollutant_name = next(
+            (x.name for x in study._river._Pollutants.Pollutants_List
+             if x.id == self._pollutant),
+            None
+        )
+
+        name = (
+            trad[self._pamhyr_name] +
+            " - " + study.name +
+            " - " + self._pollutant_name
+        )
 
         super(LateralContributionAdisTSWindow, self).__init__(
             title=name,
@@ -110,7 +123,7 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
             data=self._study.river,
             undo=self._undo_stack,
             trad=self._trad,
-            opt_data="liquid",
+            # opt_data="liquid",
             pollutant=self._pollutant,
             lcs_list=self._lcs,
         )
@@ -237,6 +250,9 @@ class LateralContributionAdisTSWindow(PamhyrWindow):
 
     def edit(self):
         rows = self.index_selected_rows()
+        if not rows:
+            return
+
         for row in rows:
             data = self._lcs.lst[row]
 

src/View/Pollutants/Window.py

@@ -217,7 +217,8 @@ class PollutantsWindow(PamhyrWindow):
             initial = InitialConditionsAdisTSWindow(
                 study=self._study,
                 parent=self,
-                data=ics_adists
+                data=ics_adists,
+                pollutant_id=pollutant_id
             )
             initial.show()
 
@@ -229,7 +230,8 @@ class PollutantsWindow(PamhyrWindow):
         for row in rows:
             pollutant_id = self._pollutants_lst.get(row).id
 
-            bclist = self._study.river.boundary_conditions_adists.BCs_AdisTS_List
+            river = self._study.river
+            bclist = river.boundary_conditions_adists.BCs_AdisTS_List
             bcs_adists = [
                 x for x in bclist
                 if x.pollutant == pollutant_id
@@ -256,6 +258,9 @@ class PollutantsWindow(PamhyrWindow):
 
         pollutant_id = self._pollutants_lst.get(rows[0]).id
 
+        lclist = self._study.river.lateral_contributions_adists.Lat_Cont_List
+        lcs_adists = [x for x in lclist if x.pollutant == pollutant_id]
+
         if self.sub_window_exists(
             LateralContributionAdisTSWindow,
             data=[self._study, pollutant_id, None]
@@ -264,8 +269,9 @@ class PollutantsWindow(PamhyrWindow):
 
         lateral = LateralContributionAdisTSWindow(
             study=self._study,
-            pollutant=pollutant_id,
+            parent=self,
-            parent=self
+            data=lcs_adists,
+            pollutant_id=pollutant_id,
         )
         lateral.show()
 

src/View/Tools/FlexibleDoubleSpinBox.py

@@ -23,7 +23,6 @@ from PyQt5.QtWidgets import QDoubleSpinBox
 
 
 class FlexibleDoubleSpinBox(QDoubleSpinBox):
-    
     def keyPressEvent(self, event):
         if event.text() == ".":
             # Simule une virgule à la place du point