implement pseduo nkode api

src/pseudo_nkode_api.py

@@ -0,0 +1,118 @@
+from uuid import UUID, uuid4
+from pydantic import BaseModel
+from src.models import EncipheredNKode
+from src.user_cipher_keys import UserCipherKeys
+from src.nkode_interface import NKodeInterface
+from src.utils import generate_random_index_interface, disperse_interface
+
+
+class UserDBModel(BaseModel):
+    username: str
+    nkode: EncipheredNKode
+    user_keys: UserCipherKeys
+    user_interface: list[list[int]]
+
+
+class CustomerDBModel(BaseModel):
+    customer_id: UUID
+    interface: NKodeInterface
+    users: list[UserDBModel]
+
+
+class SessionCacheModel(BaseModel):
+    session_id: UUID
+    set_interface: list[list[int]] | None
+    confirm_interface: list[list[int]] | None
+    set_key_entry: list[int] | None
+    confirm_key_entry: list[int] | None
+    customer_id: UUID
+    username: str
+
+    #   timeout: datetime
+
+    def create_user(self, customer_interface: NKodeInterface) -> UserDBModel:
+        assert (
+                self.set_interface and
+                self.confirm_interface and
+                self.set_key_entry and
+                self.confirm_key_entry
+        )
+        nkode_attr_indices = self._determine_user_nkode_attr_set_index()
+        customer_interface.interface
+
+    def _determine_user_nkode_attr_set_index(self) -> list[int]:
+        set_entry = self.set_key_entry
+        confirm_entry = self.confirm_key_entry
+        assert (len(set_entry) == len(confirm_entry))
+        set_key_vals = [self.set_interface[key] for key in set_entry]
+        confirm_key_vals = [self.confirm_interface[key] for key in confirm_entry]
+        overlap = list(set(set_entry) & set(confirm_entry))
+        return overlap
+
+
+class PseudoNKodeAPI(BaseModel):
+    numb_of_keys: int = 10
+    attrs_per_key: int = 7
+    customers: dict[UUID, CustomerDBModel]
+    sessions: dict[UUID, SessionCacheModel]
+
+    def generate_index_interface(self, customer_id: UUID) -> tuple[UUID, list[list[int]]]:
+        assert (customer_id in self.customers.keys())
+        new_session = SessionCacheModel(
+            session_id=uuid4(),
+            set_interface=generate_random_index_interface(self.numb_of_keys, self.attrs_per_key),
+            customer_id=customer_id
+        )
+        return new_session.session_id, new_session.set_interface
+
+    def get_login_index_interface(self):
+        pass
+
+    def set_nkode(
+            self, username: str, customer_id: UUID,
+            key_selection: list[int], session_id: UUID) -> list[list[int]]:
+        assert (username not in [user.username for user in self.customers[customer_id].users])
+        assert (session_id in self.sessions.keys())
+        assert (customer_id == self.sessions[session_id].customer_id)
+        assert (all(0 <= key <= self.numb_of_keys for key in key_selection))
+        self.sessions[session_id].username = username
+        self.sessions[session_id].set_key_entry = key_selection
+        self.sessions[session_id].confirm_interface = disperse_interface(self.sessions[session_id].set_interface)
+        return self.sessions[session_id].confirm_interface
+
+    def confirm_nkode(self, username: str, customer_id: UUID, key_selection: list[int], session_id: UUID):
+        assert (
+                session_id in self.sessions.keys() and
+                customer_id == self.sessions[session_id].customer_id and
+                username == self.sessions[session_id].username and
+                all(0 <= key <= self.numb_of_keys for key in key_selection)
+        )
+        customer = self.customers[customer_id]
+        numb_of_keys = customer.interface.numb_keys
+        attrs_per_key = customer.interface.numb_of_sets
+        set_values = customer.interface.set_vals
+        new_user_keys = UserCipherKeys.new_user_encipher_keys(numb_of_keys, attrs_per_key, set_values)
+
+        new_user = UserDBModel(
+            username=username,
+            nkode=EncipheredNKode(),
+            user_keys=new_user_keys,
+            user_interface=self.sessions[session_id].confirm_interface
+        )
+        self.customers[customer_id].users.append(new_user)
+
+    def login(self):
+        pass
+
+    def renew_keys(self):
+        pass
+
+    def create_new_customer(self, numb_keys: int, numb_sets: int) -> CustomerDBModel:
+        new_customer = CustomerDBModel(
+            customer_id=uuid4(),
+            interface=NKodeInterface.new_interface(numb_keys, numb_sets),
+            users=[],
+        )
+        self.customers[new_customer.customer_id] = new_customer
+
+        return new_customer