Friction: Rename 'Section' to 'Friction'.

src/Model/Friction/Friction.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+
+from tools import trace, timer
+
+from Model.DB import SQLSubModel
+
+class Friction(SQLSubModel):
+    def __init__(self, name:str = "", status = None):
+        super(Friction, self).__init__()
+
+        self._status = status
+
+        self._name = name
+        self._edge = None
+        self._begin_kp = 0.0
+        self._end_kp = 0.0
+        self._begin_strickler = None
+        self._end_strickler = None
+
+    @classmethod
+    def _sql_create(cls, execute):
+        execute("""
+          CREATE TABLE friction(
+            id INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+            ind INTERGER NOT NULL,
+            begin_kp REAL NOT NULL,
+            end_kp REAL NOT NULL,
+            reach INTEGER NOT NULL,
+            begin_strickler INTERGER,
+            end_strickler INTERGER,
+            FOREIGN KEY(reach) REFERENCES river_reach(id),
+            FOREIGN KEY(begin_strickler) REFERENCES stricklers(id),
+            FOREIGN KEY(end_strickler) REFERENCES stricklers(id)
+          )
+        """)
+
+        return True
+
+    @classmethod
+    def _sql_update(cls, execute, version):
+        return True
+
+    @classmethod
+    def _sql_load(cls, execute, data = None):
+        new = []
+        reach = data["parent"]  # Reach object
+        status = data["status"]
+        stricklers = data["stricklers"].stricklers
+
+        table = execute(
+            "SELECT ind, begin_kp, end_kp, begin_strickler, end_strickler " +
+            f"FROM friction WHERE reach = {reach.id}"
+        )
+
+        for _ in table:
+            new.append(None)
+
+        for row in table:
+            ind = row[0]
+            # Get stricklers
+            bs = next(filter(lambda s: s.id == row[3], stricklers))
+            es = next(filter(lambda s: s.id == row[4], stricklers))
+
+            # Create friction
+            sec = cls(status = status)
+            sec.edge = reach
+            sec.begin_kp = row[1]
+            sec.end_kp = row[2]
+            sec.begin_strickler = bs
+            sec.end_strickler = es
+
+            new[ind] = sec
+
+        return new
+
+    def _sql_save(self, execute, data = None):
+        ind = data["ind"]
+        execute(
+            "INSERT INTO " +
+            "friction(ind, begin_kp, end_kp, reach, begin_strickler, end_strickler) " +
+            "VALUES (" +
+            f"{ind}, {self._begin_kp}, {self._end_kp}, " +
+            f"{self._edge.id}, " +
+            f"{self._begin_strickler.id}, {self._end_strickler.id}" +
+            ")"
+        )
+
+        return True
+
+    @property
+    def name(self):
+        return self._name
+
+    @name.setter
+    def name(self, name):
+        self._name = name
+        self._status.modified()
+
+    @property
+    def edge(self):
+        return self._edge
+
+    @edge.setter
+    def edge(self, edge):
+        self._edge = edge
+        if (edge is not None and
+            self._begin_kp == 0.0 and
+            self._end_kp == 0.0):
+            self._begin_kp = self._edge.reach.get_kp_min()
+            self._end_kp = self._edge.reach.get_kp_max()
+        self._status.modified()
+
+    def has_edge(self):
+        return self._edge is not None
+
+    @property
+    def begin_kp(self):
+        return self._begin_kp
+
+    @begin_kp.setter
+    def begin_kp(self, begin_kp):
+        if self._edge is None:
+            self._begin_kp = begin_kp
+        else:
+            _min = self._edge.reach.get_kp_min()
+            _max = self._edge.reach.get_kp_max()
+
+            if _min <= begin_kp <= _max:
+                self._begin_kp = begin_kp
+
+        self._status.modified()
+
+    @property
+    def end_kp(self):
+        return self._end_kp
+
+    @end_kp.setter
+    def end_kp(self, end_kp):
+        if self._edge is None:
+            self._end_kp = end_kp
+        else:
+            _min = self._edge.reach.get_kp_min()
+            _max = self._edge.reach.get_kp_max()
+
+            if _min <= end_kp <= _max:
+                self._end_kp = end_kp
+
+        self._status.modified()
+
+    @property
+    def begin_strickler(self):
+        return self._begin_strickler
+
+    @begin_strickler.setter
+    def begin_strickler(self, strickler):
+        self._begin_strickler = strickler
+        self._status.modified()
+
+    @property
+    def end_strickler(self):
+        return self._end_strickler
+
+    @end_strickler.setter
+    def end_strickler(self, strickler):
+        self._end_strickler = strickler
+        self._status.modified()

src/Model/Friction/FrictionList.py

@@ -0,0 +1,122 @@
+# -*- coding: utf-8 -*-
+
+import logging
+
+from copy import copy
+from tools import trace, timer
+
+from Model.DB import SQLSubModel
+from Model.Friction.Friction import Friction
+
+logger = logging.getLogger()
+
+class FrictionList(SQLSubModel):
+    _sub_classes = [
+        Friction
+    ]
+
+    def __init__(self, status = None):
+        super(FrictionList, self).__init__()
+
+        self._status = status
+        self._frictions = []
+
+    @classmethod
+    def _sql_create(cls, execute):
+        return cls._create_submodel(execute)
+
+    @classmethod
+    def _sql_update_0_0_1(cls, execute, version):
+        execute("ALTER TABLE `section` RENAME TO `friction`")
+
+    @classmethod
+    def _sql_update(cls, execute, version):
+        if version == "0.0.0":
+            logger.info(f"Update friction TABLE from {version}")
+            cls._sql_update_0_0_1(execute, version)
+
+        return True
+
+    @classmethod
+    def _sql_load(cls, execute, data = None):
+        new = cls(status = data['status'])
+
+        new._frictions = Friction._sql_load(
+            execute, data
+        )
+
+        return new
+
+    def _sql_save(self, execute, data = None):
+        reach = data["reach"]
+        execute(f"DELETE FROM friction WHERE reach = {reach.id}")
+
+        ok = True
+        ind = 0
+        for friction in self._frictions:
+            data["ind"] = ind
+            ok &= friction._sql_save(execute, data = data)
+            ind += 1
+
+        return ok
+
+    def __len__(self):
+        return len(self._frictions)
+
+    @property
+    def frictions(self):
+        return self._frictions.copy()
+
+    def get(self, row):
+        return self._frictions[row]
+
+    def set(self, row, new):
+        self._frictions[row] = new
+        self._status.modified()
+
+    def new(self, index):
+        n = Friction(status = self._status)
+        self._frictions.insert(index, n)
+        self._status.modified()
+        return n
+
+    def insert(self, index, new):
+        self._frictions.insert(index, new)
+        self._status.modified()
+
+    def delete(self, frictions):
+        for friction in frictions:
+            self._frictions.remove(friction)
+        self._status.modified()
+
+    def delete_i(self, indexes):
+        frictions = list(
+            map(
+                lambda x: x[1],
+                filter(
+                    lambda x: x[0] in indexes,
+                    enumerate(self._frictions)
+                )
+            )
+        )
+        self.delete(frictions)
+
+    def sort(self, reverse=False, key=None):
+        self._frictions.sort(reverse=reverse, key=key)
+        self._status.modified()
+
+    def move_up(self, index):
+        if index < len(self._frictions):
+            next = index - 1
+
+            l = self._frictions
+            l[index], l[next] = l[next], l[index]
+            self._status.modified()
+
+    def move_down(self, index):
+        if index >= 0:
+            prev = index + 1
+
+            l = self._frictions
+            l[index], l[prev] = l[prev], l[index]
+            self._status.modified()