1125 implement permission system algorithm

backend/root/utils/permission_algorithm.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+
+class Permissions:
+    def __init__(self, dictionary: dict):
+        self.dict = {k: set(v) for k, v in dictionary.items()}
+        self.index_array = list(dictionary.keys())
+
+    def __getitem__(self, key: int) -> str:
+        return ''.join(sorted(self.dict[self.index_array[key]]))
+
+    def __str__(self) -> str:
+        return str({k: ''.join(sorted(v)) for k, v in self.dict.items()})
+
+    def get(self, index: int) -> set:
+        return self.dict[self.index_array[index]]
+
+    def set(self, key: str, value: str) -> None:
+        if key in self.dict:
+            self.dict[key].update(value)
+        else:
+            raise KeyError("Key not found in permissions dictionary")
+
+    def get_index_array(self) -> list:
+        return self.index_array
+
+
+class Graph:
+    def __init__(self, vertices: int, graph: list):
+        self.V = vertices
+        self.graph = graph
+
+    def __str__(self) -> str:
+        matrix_str = ''
+        for row in self.graph:
+            for value in row:
+                matrix_str += '%7d\t' % value
+            matrix_str += '\n'
+        return matrix_str
+
+    def compute_permissions(self, permissions: Permissions) -> Permissions:
+        reach = [row[:] for row in self.graph]
+        index_array = permissions.get_index_array()
+
+        for k in range(self.V):
+            for i in range(self.V):
+                for j in range(self.V):
+                    if reach[i][j] or (reach[i][k] and reach[k][j]):
+                        reach[i][j] = 1
+                        permissions.set(index_array[j], permissions.get(i))
+        # Update the graph's own matrix to reflect the transitive closure
+        self.graph = reach
+        return permissions

backend/samfundet/tests/test_permission.py

@@ -0,0 +1,52 @@
+from __future__ import annotations
+import pytest
+from samfundet.root.utils import Graph, Permissions  # Adjust the import according to your project structure.
+
+def test_graph_compute_permissions():
+    # Setup graph and permissions data.
+    graph_data = [
+        [1, 0, 1, 0, 0],
+        [0, 1, 1, 0, 1],
+        [0, 0, 1, 1, 0],
+        [0, 0, 0, 1, 0],
+        [0, 0, 0, 0, 1],
+    ]
+    permissions_data = {
+        'Ansatt': 'B',
+        'Hest': 'A',
+        'Mellomleder': 'C',
+        'Sjef': 'D',
+        'Baltazar': 'E',
+    }
+
+    # Create instances of Graph and Permissions
+    p = Permissions(permissions_data)
+    g = Graph(5, graph_data)
+
+    # Compute permissions
+    updated_permissions = g.compute_permissions(p)
+
+    # Define expected results
+    expected_permissions = {
+        'Ansatt': 'ABCDE',
+        'Hest': 'ABCDE',
+        'Mellomleder': 'CD',
+        'Sjef': 'D',
+        'Baltazar': 'E'
+    }
+
+    # Assertions to check the correctness of the permissions computation
+    for key, value in expected_permissions.items():
+        assert ''.join(sorted(updated_permissions.dict[key])) == value, f"Mismatch in permissions for {key}"
+
+    expected_graph = [
+        [1, 1, 1, 1, 1],
+        [1, 1, 1, 1, 1],
+        [0, 0, 1, 1, 1],
+        [0, 0, 0, 1, 1],
+        [0, 0, 0, 0, 1]
+    ]
+    assert g.graph == expected_graph, "Graph transitive closure incorrect"
+
+if __name__ == "__main__":
+    pytest.main()