kosh/unnamed-password-manager
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Cleaned backed/data_handler.py code.

Browse Source
This commit is contained in:
Kosh 2023-10-09 18:58:26 +05:30
parent fb4c7eef88
commit de73b8ca13
1 changed files with 72 additions and 84 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

156
backend/data_handler.py
View File

@ -6,170 +6,158 @@ file_path: str = "/home/kosh/.local/share/kosh_pass/data.json"
password_check_path: str = "/home/kosh/.local/share/kosh_pass/password_check" password_check_path: str = "/home/kosh/.local/share/kosh_pass/password_check"
class DataHandler: class DataHandler:
@staticmethod def __get_file_data(self) -> dict[str, dict[str, str]]:
def __get_file_data() -> dict[str, dict[str, str]]: with open(file_path, "r", encoding="utf8") as file:
with open(file_path) as file:
return json.load(file) return json.load(file)
@staticmethod def __write_file_data(self, data: dict[str, dict[str, str]]) -> None:
def __write_file_data(data: dict[str, dict[str, str]]) -> None: with open(file_path, "w", encoding="utf8") as file:
with open(file_path, "w") as file:
json.dump(data, file) json.dump(data, file)
@staticmethod def set_password(self, password: str) -> None:
def set_password(password: str) -> None:
with open(password_check_path, "wb") as password_check_file: with open(password_check_path, "wb") as password_check_file:
password_check_file.write( password_check_file.write(
EncryptionHandler.encrypt("Correct".encode(), password.encode()) EncryptionHandler.encrypt("Correct".encode(), password.encode())
) )
@staticmethod def verify_password(self, password: str) -> None:
def verify_password(password: str) -> None:
with open(password_check_path, "rb") as password_check_file: with open(password_check_path, "rb") as password_check_file:
EncryptionHandler.decrypt(password_check_file.read(), password.encode()) EncryptionHandler.decrypt(password_check_file.read(), password.encode())
@staticmethod def change_password(self, old_password: str, new_password: str) -> None:
def change_password(old_password: str, new_password: str) -> None: self.verify_password(old_password)
DataHandler.verify_password(old_password)
data: dict[str, dict[str, str]] = {} data: dict[str, dict[str, str]] = {}
for entry_name in DataHandler.get_entry_names(): for entry_name in self.get_entry_names():
data[entry_name] = {} data[entry_name] = {}
for field_name in DataHandler.get_field_names(entry_name): for field_name in self.get_field_names(entry_name):
data[entry_name][field_name] = \ data[entry_name][field_name] = \
DataHandler.get_field_data(entry_name, field_name, old_password) self.get_field_data(entry_name, field_name, old_password)
DataHandler.set_password(new_password) self.set_password(new_password)
DataHandler.__write_file_data({}) self.__write_file_data({})
for entry_name in data: for entry_name in data:
DataHandler.add_entry(entry_name) self.add_entry(entry_name)
for field_name in data[entry_name]: for field_name in data[entry_name]:
DataHandler.add_field( self.add_field(
entry_name, field_name, data[entry_name][field_name], new_password entry_name, field_name, data[entry_name][field_name], new_password
) )
@staticmethod def add_entry(self, entry_name: str) -> None:
def add_entry(entry_name: str) -> None: data = self.__get_file_data()
data = DataHandler.__get_file_data()
if entry_name in data: if entry_name in data:
raise ValueError(f"An entry with the name {entry_name} already exists.") raise ValueError(f"An entry with the name {entry_name} already exists.")
data[entry_name] = {} data[entry_name] = {}
DataHandler.__write_file_data(data) self.__write_file_data(data)
@staticmethod def delete_entry(self, entry_name: str) -> None:
def delete_entry(entry_name: str) -> None: data = self.__get_file_data()
data = DataHandler.__get_file_data()
try: try:
data.pop(entry_name) data.pop(entry_name)
except KeyError: except KeyError:
raise ValueError(f"No entry with name \"{entry_name}\"") raise ValueError(f"No entry with name \"{entry_name}\"") from KeyError
DataHandler.__write_file_data(data) self.__write_file_data(data)
@staticmethod def edit_entry_name(self, entry_name: str, new_entry_name: str) -> None:
def edit_entry_name(entry_name: str, new_entry_name: str) -> None: if new_entry_name in self.get_entry_names():
if new_entry_name in DataHandler.get_entry_names():
raise ValueError(f"\"{new_entry_name}\" already exists") raise ValueError(f"\"{new_entry_name}\" already exists")
if entry_name not in DataHandler.get_entry_names(): if entry_name not in self.get_entry_names():
raise ValueError(f"No entry with name \"{entry_name}\"") raise ValueError(f"No entry with name \"{entry_name}\"")
fields: dict[str, str] = DataHandler.__get_file_data()[entry_name] fields: dict[str, str] = self.__get_file_data()[entry_name]
DataHandler.delete_entry(entry_name) self.delete_entry(entry_name)
data = DataHandler.__get_file_data() data = self.__get_file_data()
data[new_entry_name] = fields data[new_entry_name] = fields
DataHandler.__write_file_data(data) self.__write_file_data(data)
@staticmethod def get_entry_names(self, ) -> list[str]:
def get_entry_names() -> list[str]: return list(self.__get_file_data().keys())
return list(DataHandler.__get_file_data().keys())
@staticmethod def add_field(self,
def add_field(
entry_name: str, entry_name: str,
field_name: str, field_name: str,
field_value: str, field_value: str,
password: str password: str
) -> None: ) -> None:
DataHandler.verify_password(password) self.verify_password(password)
if entry_name not in DataHandler.get_entry_names(): if entry_name not in self.get_entry_names():
raise ValueError(f"No entry with name {entry_name}") raise ValueError(f"No entry with name {entry_name}")
if field_name in DataHandler.get_field_names(entry_name): if field_name in self.get_field_names(entry_name):
raise ValueError(f"Field {field_name} already exists under entry {entry_name}") raise ValueError(f"Field {field_name} already exists under entry {entry_name}")
data: dict[str, dict[str, str]] = DataHandler.__get_file_data() data: dict[str, dict[str, str]] = self.__get_file_data()
data[entry_name][field_name] = EncryptionHandler.encrypt( data[entry_name][field_name] = EncryptionHandler.encrypt(
field_value.encode(), field_value.encode(),
password.encode() password.encode()
).decode("unicode-escape") ).decode("unicode-escape")
DataHandler.__write_file_data(data) self.__write_file_data(data)
@staticmethod def delete_field(self, entry_name: str, field_name: str) -> None:
def delete_field(entry_name: str, field_name: str) -> None: if entry_name not in self.get_entry_names():
if entry_name not in DataHandler.get_entry_names():
raise ValueError(f"No entry with name \"{entry_name}\"") raise ValueError(f"No entry with name \"{entry_name}\"")
if field_name not in DataHandler.get_field_names(entry_name): if field_name not in self.get_field_names(entry_name):
raise ValueError(f"{entry_name} does not have field {field_name}") raise ValueError(f"{entry_name} does not have field {field_name}")
data = DataHandler.__get_file_data() data = self.__get_file_data()
data[entry_name].pop(field_name) data[entry_name].pop(field_name)
DataHandler.__write_file_data(data) self.__write_file_data(data)
@staticmethod def edit_field_name(self, entry_name: str, field_name: str, new_field_name: str) -> None:
def edit_field_name(entry_name: str, field_name: str, new_field_name: str) -> None: if entry_name not in self.get_entry_names():
if entry_name not in DataHandler.get_entry_names():
raise ValueError(f"No entry with name \"{entry_name}\"") raise ValueError(f"No entry with name \"{entry_name}\"")
if field_name not in DataHandler.get_field_names(entry_name): if field_name not in self.get_field_names(entry_name):
raise ValueError(f"{entry_name} does not have field {field_name}") raise ValueError(f"{entry_name} does not have field {field_name}")
if new_field_name in DataHandler.get_field_names(entry_name): if new_field_name in self.get_field_names(entry_name):
raise ValueError(f"{entry_name} does has a field {new_field_name}") raise ValueError(f"{entry_name} does has a field {new_field_name}")
field_data = DataHandler.__get_file_data()[entry_name][field_name] field_data = self.__get_file_data()[entry_name][field_name]
DataHandler.delete_field(entry_name, field_name) self.delete_field(entry_name, field_name)
data = DataHandler.__get_file_data() data = self.__get_file_data()
data[entry_name][new_field_name] = field_data data[entry_name][new_field_name] = field_data
DataHandler.__write_file_data(data) self.__write_file_data(data)
@staticmethod def edit_field_value(self,
def edit_field_value(
entry_name: str, entry_name: str,
field_name: str, field_name: str,
new_value: str, new_value: str,
password: str password: str
) -> None: ) -> None:
DataHandler.verify_password(password) self.verify_password(password)
if entry_name not in DataHandler.get_entry_names(): if entry_name not in self.get_entry_names():
raise ValueError(f"No entry called {entry_name}") raise ValueError(f"No entry called {entry_name}")
if field_name not in DataHandler.get_field_names(entry_name): if field_name not in self.get_field_names(entry_name):
raise ValueError(f"No field called {field_name} under {entry_name}") raise ValueError(f"No field called {field_name} under {entry_name}")
self.delete_field(entry_name, field_name)
self.add_field(entry_name, field_name, new_value, password)
DataHandler.delete_field(entry_name, field_name) def get_field_data(self, entry_name: str, field_name: str, password: str) -> str:
DataHandler.add_field(entry_name, field_name, new_value, password) self.verify_password(password)
if field_name not in self.get_field_names(entry_name):
@staticmethod
def get_field_data(entry_name: str, field_name: str, password: str) -> str:
DataHandler.verify_password(password)
if field_name not in DataHandler.get_field_names(entry_name):
raise ValueError(f"No field with name {field_name} under {entry_name}.") raise ValueError(f"No field with name {field_name} under {entry_name}.")
encrypted_data = DataHandler.__get_file_data()[entry_name][field_name].encode("ISO-8859-1") encrypted_data = self.__get_file_data()[entry_name][field_name].\
plain_data = EncryptionHandler.decrypt(encrypted_data, password.encode("ISO-8859-1")).decode("utf-8") encode("ISO-8859-1")
plain_data = EncryptionHandler.decrypt(
encrypted_data,
password.encode("ISO-8859-1")
).decode("utf-8")
return plain_data return plain_data
@staticmethod def get_field_names(self, entry_name: str) -> list[str]:
def get_field_names(entry_name: str) -> list[str]: data = self.__get_file_data()
data = DataHandler.__get_file_data()
if entry_name not in data: if entry_name not in data:
raise ValueError(f"No entry with name {entry_name}.") raise ValueError(f"No entry with name {entry_name}.")
return list(data[entry_name].keys()) return list(data[entry_name].keys())
@staticmethod
def add_entry_and_fields( def add_entry_and_fields(
self,
entry_name: str, entry_name: str,
fields: dict[str, str], fields: dict[str, str],
password: str password: str
) -> None: ) -> None:
DataHandler.verify_password(password) self.verify_password(password)
if entry_name in DataHandler.get_entry_names(): if entry_name in self.get_entry_names():
raise ValueError(f"Entry {entry_name} already exists.") raise ValueError(f"Entry {entry_name} already exists.")
DataHandler.add_entry(entry_name) self.add_entry(entry_name)
for field_name, field_value in fields.items(): for field_name, field_value in fields.items():
print(field_name, field_value) print(field_name, field_value)
DataHandler.add_field(entry_name, field_name, field_value, password) self.add_field(entry_name, field_name, field_value, password)