refactor code

src/pseudo_nkode_api.py

@@ -1,110 +0,0 @@
-from uuid import UUID, uuid4
-from pydantic import BaseModel
-
-from src.customer_db_model import CustomerDBModel
-from src.session_cache import SessionCacheModel
-from src.user_cipher_keys import UserCipherKeys
-from src.user_db_model import UserDBModel
-from src.user_interface import UserInterface
-from src.customer_interface import CustomerInterface
-
-
-class PseudoNKodeAPI(BaseModel):
-    customers: dict[UUID, CustomerDBModel] = {}
-    sessions: dict[UUID, SessionCacheModel] = {}
-
-    def generate_index_interface(self, customer_id: UUID) -> tuple[UUID, list[int]]:
-        assert (customer_id in self.customers.keys())
-        customer = self.customers[customer_id]
-        set_interface = UserInterface.new_interface(customer.interface.attrs_per_key, customer.interface.numb_keys)
-        new_session = SessionCacheModel(
-            session_id=uuid4(),
-            set_interface=set_interface.interface_index,
-            customer_id=customer_id,
-        )
-        self.sessions[new_session.session_id] = new_session
-        return new_session.session_id, new_session.set_interface
-
-    def get_login_index_interface(self, username: str, customer_id: UUID) -> list[int]:
-        """
-        TODO: how do we prevent a targeted denial-of-service attack?
-        """
-        assert (customer_id in self.customers.keys())
-        customer = self.customers[customer_id]
-        assert (username in customer.users.keys())
-        user = customer.users[username]
-        user.user_interface.shuffle_interface()
-        return user.user_interface.interface_index
-
-    def set_nkode(
-            self, username: str, customer_id: UUID,
-            key_selection: list[int], session_id: UUID) -> list[int]:
-        assert (customer_id in self.customers.keys())
-        customer = self.customers[customer_id]
-        assert (username not in customer.users.keys())
-        assert (session_id in self.sessions.keys())
-        session = self.sessions[session_id]
-        assert (customer_id == session.customer_id)
-        numb_of_keys = customer.interface.numb_keys
-        attrs_per_key = customer.interface.attrs_per_key
-        assert (all(0 <= key <= numb_of_keys for key in key_selection))
-        set_interface = UserInterface(
-            interface_index=session.set_interface,
-            numb_sets=attrs_per_key,
-            numb_keys=numb_of_keys,
-        )
-        set_interface.disperse_interface()
-        session.username = username
-        session.set_key_entry = key_selection
-        session.confirm_interface = set_interface.interface_index
-        self.sessions[session_id] = session
-        return self.sessions[session_id].confirm_interface
-
-    def confirm_nkode(self, username: str, customer_id: UUID, confirm_key_entry: 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
-        )
-        session = self.sessions[session_id]
-        customer = self.customers[customer_id]
-        numb_of_keys = customer.interface.numb_keys
-        attrs_per_key = customer.interface.attrs_per_key
-        assert (all(0 <= key <= numb_of_keys for key in confirm_key_entry))
-        passcode = session.deduce_passcode(attrs_per_key, confirm_key_entry)
-        set_values = customer.interface.set_vals
-        new_user_keys = UserCipherKeys.new_user_encipher_keys(numb_of_keys, attrs_per_key, set_values)
-        enciphered_passcode = new_user_keys.encipher_nkode(passcode, customer.interface)
-        new_user = UserDBModel(
-            username=username,
-            enciphered_passcode=enciphered_passcode,
-            user_keys=new_user_keys,
-            user_interface=UserInterface(
-                interface_index=self.sessions[session_id].confirm_interface,
-                numb_sets=attrs_per_key,
-                numb_keys=numb_of_keys,
-            ),
-        )
-        self.customers[customer_id].add_new_user(new_user)
-        return "success"
-        # del self.sessions[session_id]
-
-
-    def login(self, customer_id: UUID, username: str, key_selection: list[int]) -> bool:
-        assert (customer_id in self.customers.keys())
-        customer = self.customers[customer_id]
-        return customer.valid_key_entry(username, key_selection)
-
-    def renew_keys(self, customer_id: UUID) -> bool:
-        assert (customer_id in self.customers.keys())
-        return self.customers[customer_id].renew_keys()
-
-    def create_new_customer(self, numb_keys: int, numb_sets: int) -> CustomerDBModel:
-        new_customer = CustomerDBModel(
-            customer_id=uuid4(),
-            interface=CustomerInterface.new_interface(numb_keys, numb_sets),
-            users={},
-        )
-        self.customers[new_customer.customer_id] = new_customer
-
-        return new_customer