merge

src/Model/HydraulicStructures/Basic/HydraulicStructures.py

@@ -80,11 +80,15 @@ class BasicHS(SQLSubModel):
 
     @classmethod
     def _get_ctor_from_type(cls, t):
-        from Model.HydraulicStructure.Basic.Types import (
-            NotDefined,
+        from Model.HydraulicStructures.Basic.Types import (
+            NotDefined, Dummy,
         )
 
         res = NotDefined
+
+        if t == "DU":
+            res = Dummy
+
         return res
 
     @classmethod
@@ -93,7 +97,8 @@ class BasicHS(SQLSubModel):
 
         table = execute(
             "SELECT id, name, type, enabled, hs " +
-            "FROM hydraulic_structures "
+            "FROM hydraulic_structures_basic " +
+            f"WHERE hs = {data['hs_id']} "
         )
 
         for row in table:
@@ -113,7 +118,7 @@ class BasicHS(SQLSubModel):
             bhs.enabled = enabled
 
             data['bhs_id'] = bhs_id
-            bhs._data = BasicHSValue._db_load(
+            bhs._data = BHSValue._db_load(
                 execute, data
             )
 
@@ -144,7 +149,7 @@ class BasicHS(SQLSubModel):
         data['bhs_id'] = self.id
         execute(
             "DELETE FROM hydraulic_structures_basic_value " +
-            f"WHERE bhs = {bhs_id}"
+            f"WHERE bhs = {self.id}"
         )
 
         for values in self._data:
@@ -183,8 +188,8 @@ class BasicHS(SQLSubModel):
         self._status.modified()
 
     @property
-    def lst(self):
-        return self._data.copy()
+    def parameters(self):
+        return self._data
 
     def convert(self, new_type):
         return new_type(id=self.id, name=self.name, status=self._status)

src/Model/HydraulicStructures/Basic/Types.py

@@ -35,9 +35,9 @@ class NotDefined(BasicHS):
 
         self._type = "ND"
         self._data = [
-            BHSValue("foo", float, 0.0),
-            BHSValue("bar", float, 42.0),
-            BHSValue("baz", int, 13),
+            BHSValue("foo", float, 0.0, status=status),
+            BHSValue("bar", float, 42.0, status=status),
+            BHSValue("baz", int, 13, status=status),
         ]
 
 

src/Model/HydraulicStructures/HydraulicStructures.py

@@ -17,6 +17,7 @@
 # -*- coding: utf-8 -*-
 
 import logging
+from functools import reduce
 
 from tools import trace, timer, old_pamhyr_date_to_timestamp
 
@@ -117,15 +118,15 @@ class HydraulicStructure(SQLSubModel):
             )
 
             hs.enabled = enabled
-            hs.input_kp = input_kp
-            hs.output_kp = output_kp
+            hs.input_kp = input_kp if input_kp != -1 else None
+            hs.output_kp = output_kp if output_kp != -1 else None
 
             hs.input_reach, hs.output_reach = reduce(
                 lambda acc, n: (
                     n if n.id == input_reach_id else acc[0],
                     n if n.id == output_reach_id else acc[1]
                 ),
-                data["reachs"],
+                data["edges"],
                 [None, None]
             )
 

src/Model/Study.py

@@ -86,7 +86,7 @@ class Study(SQLModel):
     def is_saved(self):
         return self.status.is_saved()
 
-    def save(self):
+    def save(self, progress=None):
         # Save a copy of database
         fdir, fname = os.path.split(self.filename)
 
@@ -110,7 +110,7 @@ class Study(SQLModel):
 
         # Save
         self.last_save_date = datetime.now()
-        self._save()
+        self._save(progress=progress)
         self.status.save()
 
     @property
@@ -266,38 +266,54 @@ class Study(SQLModel):
 
         return new
 
-    def _save(self):
+    def _save(self, progress=None):
+        progress = progress if progress is not None else lambda: None
+
         self.execute(
             f"UPDATE info SET " +
             f"value='{self._db_format(self.name)}' WHERE key='name'"
         )
+        progress()
         self.execute(
             f"UPDATE info SET " +
             f"value='{self._db_format(self.description)}' " +
             "WHERE key='description'"
         )
+        progress()
         self.execute(
             f"UPDATE info SET " +
             f"value='{self._time_system}' WHERE key='time_system'"
         )
+        progress()
         self.execute(
             f"UPDATE info SET " +
             f"value='{timestamp(self._date)}' WHERE key='date'"
         )
+        progress()
         self.execute(
             f"UPDATE info SET " +
             f"value='{timestamp(self.creation_date)}' " +
             "WHERE key='creation_date'"
         )
+        progress()
         self.execute(
             f"UPDATE info SET " +
             f"value='{timestamp(self.last_save_date)}' " +
             "WHERE key='last_save_date'"
         )
+        progress()
 
-        self._save_submodel([self._river])
+        self._save_submodel([self._river], data=progress)
         self.commit()
 
+    def sql_save_request_count(self):
+        return self._count()
+
+    def _count(self):
+        cnt = self._save_count([self._river])
+        logger.debug(cnt)
+        return cnt + 6
+
     def close(self):
         """Close db connection
 

src/Model/Tools/PamhyrDB.py

@@ -21,6 +21,7 @@ import sqlite3
 import logging
 
 from pathlib import Path
+from functools import reduce
 
 from tools import SQL
 from Model.Except import NotImplementedMethodeError
@@ -87,11 +88,16 @@ class SQLModel(SQL):
         raise NotImplementedMethodeError(self, self._update)
 
     def _save_submodel(self, objs, data=None):
-        def fn(sql): return self.execute(
-            sql,
-            fetch_one=False,
-            commit=False
-        )
+        progress = data if data is not None else lambda: None
+
+        def fn(sql):
+            res = self.execute(
+                sql,
+                fetch_one=False,
+                commit=False
+            )
+            progress()
+            return res
 
         ok = True
         for obj in objs:
@@ -100,9 +106,43 @@ class SQLModel(SQL):
         self.commit()
         return ok
 
-    def _save(self):
+    def _save(self, progress=None):
         raise NotImplementedMethodeError(self, self._save)
 
+    def _count(self):
+        raise NotImplementedMethodeError(self, self._count)
+
+    def _save_count(self, objs, data=None):
+        counter = {
+            "insert": 0,
+            "update": 0,
+            "delete": 0,
+            "other": 0,
+        }
+
+        def fn(sql):
+            if "insert" in sql.lower():
+                counter["insert"] = counter["insert"] + 1
+            elif "update" in sql.lower():
+                counter["update"] = counter["update"] + 1
+            elif "delete" in sql.lower():
+                counter["delete"] = counter["delete"] + 1
+            else:
+                counter["other"] = counter["other"] + 1
+            return []
+
+        ok = True
+        for obj in objs:
+            ok &= obj._db_save(fn)
+
+        logger.debug(counter)
+
+        return reduce(
+            lambda acc, k: acc + counter[k],
+            counter,
+            0
+        )
+
     @classmethod
     def _load(cls, filename=None):
         raise NotImplementedMethodeError(cls, cls._load)

src/View/HydraulicStructures/BasicHydraulicStructures/Table.py

@@ -31,14 +31,15 @@ from PyQt5.QtWidgets import (
     QDialogButtonBox, QPushButton, QLineEdit,
     QFileDialog, QTableView, QAbstractItemView,
     QUndoStack, QShortcut, QAction, QItemDelegate,
-    QComboBox,
+    QComboBox, QMessageBox,
 )
 
 from View.Tools.PamhyrTable import PamhyrTableModel
 
 from View.HydraulicStructures.BasicHydraulicStructures.UndoCommand import (
     SetNameCommand, SetTypeCommand,
-    AddCommand, DelCommand,
+    SetEnabledCommand, AddCommand, DelCommand,
+    SetValueCommand,
 )
 from Model.HydraulicStructures.Basic.Types import BHS_types
 
@@ -61,15 +62,13 @@ class ComboBoxDelegate(QItemDelegate):
     def createEditor(self, parent, option, index):
         self.editor = QComboBox(parent)
 
-
         lst = list(
             map(
-                lambda k: self._long_types[k], BHS_types.keys()
+                lambda k: self._long_types[k],
+                BHS_types.keys()
             )
         )
-        self.editor.addItems(
-            lst
-        )
+        self.editor.addItems(lst)
 
         self.editor.setCurrentText(index.data(Qt.DisplayRole))
         return self.editor
@@ -137,20 +136,35 @@ class TableModel(PamhyrTableModel):
                     )
                 )
             elif self._headers[column] == "type":
-                key = next(k for k, v in self._long_types.items()
-                           if v == value)
-                self._undo.push(
-                    SetTypeCommand(
-                        self._data, row, BHS_types[key]
+                if self._question_set_type():
+                    key = next(
+                        k for k, v in self._long_types.items()
+                        if v == value
+                    )
+
+                    self._undo.push(
+                        SetTypeCommand(
+                            self._data, row, BHS_types[key]
+                        )
                     )
-                )
         except Exception as e:
-            logger.info(e)
+            logger.error(e)
             logger.debug(traceback.format_exc())
 
         self.dataChanged.emit(index, index)
         return True
 
+    def _question_set_type(self):
+        question = QMessageBox(self._parent)
+
+        question.setWindowTitle(self._trad['msg_type_change_title'])
+        question.setText(self._trad['msg_type_change_text'])
+        question.setStandardButtons(QMessageBox.Cancel | QMessageBox.Ok)
+        question.setIcon(QMessageBox.Question)
+
+        res = question.exec()
+        return res == QMessageBox.Ok
+
     def add(self, row, parent=QModelIndex()):
         self.beginInsertRows(parent, row, row - 1)
 
@@ -175,6 +189,14 @@ class TableModel(PamhyrTableModel):
         self.endRemoveRows()
         self.layoutChanged.emit()
 
+    def enabled(self, row, enabled, parent=QModelIndex()):
+        self._undo.push(
+            SetEnabledCommand(
+                self._lst, row, enabled
+            )
+        )
+        self.layoutChanged.emit()
+
     def undo(self):
         self._undo.undo()
         self.layoutChanged.emit()
@@ -182,3 +204,72 @@ class TableModel(PamhyrTableModel):
     def redo(self):
         self._undo.redo()
         self.layoutChanged.emit()
+
+
+class ParametersTableModel(PamhyrTableModel):
+    def __init__(self, trad=None, **kwargs):
+        self._trad = trad
+        self._long_types = {}
+
+        if self._trad is not None:
+            self._long_types = self._trad.get_dict("long_types")
+
+        self._hs_index = None
+
+        super(ParametersTableModel, self).__init__(trad=trad, **kwargs)
+
+    def rowCount(self, parent):
+        if self._hs_index is None:
+            return 0
+
+        return len(
+            self._data.basic_structure(self._hs_index)
+        )
+
+    def data(self, index, role):
+        if role != Qt.ItemDataRole.DisplayRole:
+            return QVariant()
+
+        if self._hs_index is None:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        hs = self._data.basic_structure(self._hs_index)
+
+        if self._headers[column] == "name":
+            return hs.parameters[row].name
+        elif self._headers[column] == "value":
+            return str(hs.parameters[row].value)
+
+        return QVariant()
+
+    def setData(self, index, value, role=Qt.EditRole):
+        if not index.isValid() or role != Qt.EditRole:
+            return False
+
+        if self._hs_index is None:
+            return QVariant()
+
+        row = index.row()
+        column = index.column()
+
+        try:
+            if self._headers[column] == "value":
+                self._undo.push(
+                    SetValueCommand(
+                        self._data.basic_structure(self._hs_index),
+                        row, value
+                    )
+                )
+        except Exception as e:
+            logger.error(e)
+            logger.debug(traceback.format_exc())
+
+        self.dataChanged.emit(index, index)
+        return True
+
+    def update_hs_index(self, index):
+        self._hs_index = index
+        self.layoutChanged.emit()

src/View/HydraulicStructures/BasicHydraulicStructures/Translate.py

@@ -27,6 +27,17 @@ class BasicHydraulicStructuresTranslate(PamhyrTranslate):
     def __init__(self):
         super(BasicHydraulicStructuresTranslate, self).__init__()
 
+        self._dict['msg_type_change_title'] = _translate(
+            "BasicHydraulicStructures",
+            "Change hydraulic structure type"
+        )
+
+        self._dict['msg_type_change_text'] = _translate(
+            "BasicHydraulicStructures",
+            "Do you want to change the hydraulic structure type and reset \
+hydraulic structure values?"
+        )
+
         self._sub_dict["long_types"] = {
             "ND": _translate("BasicHydraulicStructures", "Not defined"),
             "S1": _translate("BasicHydraulicStructures", "Seuil déversoir"),
@@ -45,3 +56,8 @@ class BasicHydraulicStructuresTranslate(PamhyrTranslate):
             "name": _translate("BasicHydraulicStructures", "Name"),
             "type": _translate("BasicHydraulicStructures", "Type"),
         }
+
+        self._sub_dict["table_headers_parameters"] = {
+            "name": _translate("BasicHydraulicStructures", "Name"),
+            "value": _translate("BasicHydraulicStructures", "Value"),
+        }

src/View/HydraulicStructures/BasicHydraulicStructures/UndoCommand.py

@@ -60,6 +60,22 @@ class SetTypeCommand(QUndoCommand):
         self._hs.insert(self._index, self._new)
 
 
+class SetEnabledCommand(QUndoCommand):
+    def __init__(self, hs, index, enabled):
+        QUndoCommand.__init__(self)
+
+        self._hs = hs
+        self._index = index
+        self._old = not enabled
+        self._new = enabled
+
+    def undo(self):
+        self._hs.basic_structure(self._index).enabled = self._old
+
+    def redo(self):
+        self._hs.basic_structure(self._index).enabled = self._new
+
+
 class AddCommand(QUndoCommand):
     def __init__(self, hs, index):
         QUndoCommand.__init__(self)
@@ -96,7 +112,7 @@ class DelCommand(QUndoCommand):
             self._hs.insert(row, el)
 
     def redo(self):
-        self._hs.delete_i([self._rows])
+        self._hs.delete_i(self._rows)
 
 
 class PasteCommand(QUndoCommand):
@@ -110,9 +126,28 @@ class PasteCommand(QUndoCommand):
         self._bhs.reverse()
 
     def undo(self):
-        self._hs.delete_i(range(self._row, self._row + len(self._bhs))
-        )
+        self._hs.delete_i(range(self._row, self._row + len(self._bhs)))
 
     def redo(self):
         for r in self._bhs:
             self._hs.insert(self._row, r)
+
+####################################
+# Basic hydraulic structure values #
+####################################
+
+
+class SetValueCommand(QUndoCommand):
+    def __init__(self, bhs, index, value):
+        QUndoCommand.__init__(self)
+
+        self._bhs = bhs
+        self._index = index
+        self._old = self._bhs.parameters[self._index].value
+        self._new = self._bhs.parameters[self._index].type(value)
+
+    def undo(self):
+        self._bhs.parameters[self._index].value = self._old
+
+    def redo(self):
+        self._bhs.parameters[self._index].value = self._new

src/View/HydraulicStructures/BasicHydraulicStructures/Window.py

@@ -41,11 +41,13 @@ from View.Tools.Plot.PamhyrToolbar import PamhyrPlotToolbar
 from View.HydraulicStructures.PlotAC import PlotAC
 
 from View.HydraulicStructures.BasicHydraulicStructures.Table import (
-    TableModel, ComboBoxDelegate
+    ComboBoxDelegate, TableModel, ParametersTableModel,
 )
 
 from View.Network.GraphWidget import GraphWidget
-from View.HydraulicStructures.BasicHydraulicStructures.Translate import BasicHydraulicStructuresTranslate
+from View.HydraulicStructures.BasicHydraulicStructures.Translate import (
+    BasicHydraulicStructuresTranslate
+)
 
 _translate = QCoreApplication.translate
 
@@ -77,6 +79,10 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
         self.setup_connections()
 
     def setup_table(self):
+        self.setup_table_bhs()
+        self.setup_table_bhs_parameters()
+
+    def setup_table_bhs(self):
         self._table = None
 
         self._delegate_type = ComboBoxDelegate(
@@ -95,6 +101,7 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
             trad=self._trad,
             data=self._hs,
             undo=self._undo_stack,
+            parent=self,
         )
 
         selectionModel = table.selectionModel()
@@ -108,6 +115,21 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
         )
         table.scrollTo(index)
 
+    def setup_table_bhs_parameters(self):
+        self._table_parameters = None
+
+        table = self.find(QTableView, f"tableView_2")
+        self._table_parameters = ParametersTableModel(
+            table_view=table,
+            table_headers=self._trad.get_dict("table_headers_parameters"),
+            editable_headers=["value"],
+            delegates={},
+            trad=self._trad,
+            data=self._hs,
+            undo=self._undo_stack,
+            parent=self,
+        )
+
     def setup_checkbox(self):
         self._checkbox = self.find(QCheckBox, f"checkBox")
         self._set_checkbox_state()
@@ -145,27 +167,29 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
     def setup_connections(self):
         self.find(QAction, "action_add").triggered.connect(self.add)
         self.find(QAction, "action_delete").triggered.connect(self.delete)
-        self._checkbox.stateChanged.connect(self._set_basic_structure_state)
+        self._checkbox.clicked.connect(self._set_basic_structure_state)
 
         table = self.find(QTableView, "tableView")
         table.selectionModel()\
-                 .selectionChanged\
-                 .connect(self.update)
+             .selectionChanged\
+             .connect(self.update)
+
+        self._table.layoutChanged.connect(self.update)
 
     def index_selected(self):
         table = self.find(QTableView, "tableView")
-        r = table.selectionModel()\
-                    .selectedRows()
-        if len(r)>0:
+        r = table.selectionModel().selectedRows()
+
+        if len(r) > 0:
             return r[0]
         else:
             return None
 
     def index_selected_row(self):
         table = self.find(QTableView, "tableView")
-        r = table.selectionModel()\
-                    .selectedRows()
-        if len(r)>0:
+        r = table.selectionModel().selectedRows()
+
+        if len(r) > 0:
             return r[0].row()
         else:
             return None
@@ -184,6 +208,7 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
 
     def add(self):
         rows = self.index_selected_rows()
+
         if len(self._hs) == 0 or len(rows) == 0:
             self._table.add(0)
         else:
@@ -191,6 +216,7 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
 
     def delete(self):
         rows = self.index_selected_rows()
+
         if len(rows) == 0:
             return
 
@@ -210,6 +236,7 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
 
     def _set_checkbox_state(self):
         row = self.index_selected_row()
+
         if row is None:
             self._checkbox.setEnabled(False)
             self._checkbox.setChecked(True)
@@ -219,14 +246,17 @@ class BasicHydraulicStructuresWindow(PamhyrWindow):
 
     def _set_basic_structure_state(self):
         row = self.index_selected_row()
-        if row is None:
-            self._checkbox.setEnabled(False)
-        else:
-            self._hs.basic_structure(row).enabled = self._checkbox.isChecked()
+
+        if row is not None:
+            self._table.enabled(
+                row,
+                self._checkbox.isChecked()
+            )
 
     def update(self):
         self._set_checkbox_state()
-        self._update_clear_plot()
+        self._update_parameters_table()
 
-    def _update_clear_plot(self):
-        rows = self.index_selected_rows()
+    def _update_parameters_table(self):
+        row = self.index_selected_row()
+        self._table_parameters.update_hs_index(row)

src/View/HydraulicStructures/PlotAC.py

@@ -106,13 +106,13 @@ class PlotAC(PamhyrPlot):
         self.update()
 
     def update(self):
-
         if self.line_kp is None:
             self.draw()
         else:
             if self._current_reach is None or self._current_profile is None:
                 self.clear()
                 return
+
             profile = self._current_profile
             x = profile.get_station()
             z = profile.z()

src/View/HydraulicStructures/Table.py

@@ -80,7 +80,7 @@ class ComboBoxDelegate(QItemDelegate):
             val
         )
 
-        self.editor.setCurrentText(index.data(Qt.DisplayRole))
+        self.editor.setCurrentText(str(index.data(Qt.DisplayRole)))
         return self.editor
 
     def setEditorData(self, editor, index):

src/View/HydraulicStructures/UndoCommand.py

@@ -92,11 +92,9 @@ class SetEnabledCommand(QUndoCommand):
         self._new = enabled
 
     def undo(self):
-        logger.info(f"Undo {self._new} -> {self._old}")
         self._h_s_lst.get(self._index).enabled = self._old
 
     def redo(self):
-        logger.info(f"Undo {self._old} -> {self._new}")
         self._h_s_lst.get(self._index).enabled = self._new
 
 

src/View/HydraulicStructures/Window.py

@@ -48,7 +48,9 @@ from View.HydraulicStructures.Table import (
 from View.Network.GraphWidget import GraphWidget
 from View.HydraulicStructures.Translate import HydraulicStructuresTranslate
 
-from View.HydraulicStructures.BasicHydraulicStructures.Window import BasicHydraulicStructuresWindow
+from View.HydraulicStructures.BasicHydraulicStructures.Window import (
+    BasicHydraulicStructuresWindow
+)
 
 _translate = QCoreApplication.translate
 

src/View/MainWindow.py

@@ -28,12 +28,12 @@ from PyQt5.QtGui import (
 )
 
 from PyQt5.QtCore import (
-    QTranslator, QEvent, QUrl,
+    Qt, QTranslator, QEvent, QUrl,
 )
 from PyQt5.QtWidgets import (
     QMainWindow, QApplication, QAction,
     QFileDialog, QShortcut, QMenu, QToolBar,
-    QMessageBox,
+    QMessageBox, QProgressDialog,
 )
 from PyQt5.uic import loadUi
 
@@ -406,8 +406,20 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         if self._study.is_saved:
             return
 
+        sql_request_count = self._study.sql_save_request_count()
+        progress = QProgressDialog(
+            "Saving...", None,
+            0, sql_request_count,
+            parent=self
+        )
+        progress.setWindowModality(Qt.WindowModal)
+        progress.setValue(0)
+
         logger.info("Save...")
-        self._study.save()
+        self._study.save(
+            progress=lambda: progress.setValue(progress.value() + 1)
+        )
+        logger.info("Done")
 
     def save_as_study(self):
         """Save current study as new file
@@ -428,7 +440,20 @@ class ApplicationWindow(QMainWindow, ListedSubWindow, WindowToolKit):
         else:
             self._study.filename = file_name + ".pamhyr"
 
-        self._study.save()
+        sql_request_count = self._study.sql_save_request_count()
+        progress = QProgressDialog(
+            "Saving...", None,
+            0, sql_request_count,
+            parent=self
+        )
+        progress.setWindowModality(Qt.WindowModal)
+        progress.setValue(0)
+
+        logger.info("Save...")
+        self._study.save(
+            progress=lambda: progress.setValue(progress.value() + 1)
+        )
+        logger.info("Done")
 
     ##################
     # MSG AND DIALOG #

src/View/Network/GraphWidget.py

@@ -178,12 +178,15 @@ class EdgeItem(QGraphicsItem):
         if self.graph.selected_item() == self:
             color = Qt.red
         elif self.graph.current_edge() == self:
-            color = Qt.black
+            color = Qt.blue
         elif not self.graph.graph.is_enable_edge(self.edge):
             color = Qt.darkGray
 
-        painter.setPen(QPen(color, 2, Qt.SolidLine, Qt.RoundCap,
-                            Qt.RoundJoin))
+        painter.setPen(
+            QPen(
+                color, 2, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin
+            )
+        )
         # Draw the line
         painter.drawLine(line)
 

src/View/Tools/PamhyrTable.py

@@ -83,7 +83,8 @@ class PamhyrTableModel(QAbstractTableModel):
                  trad=None,
                  data=None,
                  undo=None,
-                 opt_data=None):
+                 opt_data=None,
+                 parent=None):
         super(PamhyrTableModel, self).__init__()
 
         self._table_view = table_view
@@ -93,6 +94,7 @@ class PamhyrTableModel(QAbstractTableModel):
         self._editable_headers = editable_headers
         self._delegates = delegates
         self._trad = trad
+        self._parent = parent
 
         self._data = data
         self._opt_data = opt_data