class PlansHandler:
def __init__(self, file_location: str):
self.file_location = file_location
self.object_loader_pickle = ObjectLoaderPickle(self.file_location)
self.plans: [Plan] = [] # to avoid change date between 'get_id' and 'add' plans are saved to variable
def add(self, day_shift: int, hour: str, duration: int, name: str):
self.__load() # has to be called to track current day that can change
plan_id = self.__get_plan_id(day_shift)
if plan_id is None:
self.plans.append(Plan(day_shift))
plan_id = len(self.plans) - 1
add_success = self.plans[plan_id].add_task(name, duration, hour)
if add_success:
self.__save()
return add_success
def remove(self, day_shift: int, hour: str):
self.__load()
plan_id = self.__get_plan_id(day_shift)
if plan_id is None:
return False
remove_success = self.plans[plan_id].remove_task(hour)
if remove_success:
if self.plans[plan_id].is_empty():
del self.plans[plan_id]
self.__save()
return remove_success
def get(self, day_shift: int = None): # return plan for one day, or all plans if parameter == None
self.__load()
if day_shift is None:
return self.plans
else:
plan_id = self.__get_plan_id(day_shift)
if plan_id is None:
return Plan(day_shift)
else:
return self.plans[plan_id]
def __get_plan_id(self, day_shift):
current_index = 0
for plan in self.plans:
if plan.date == DateHelper.get_today_short(day_shift):
return current_index
current_index += 1
return None
def __save(self):
self.object_loader_pickle.save(self.plans)
def __load(self):
plans = self.object_loader_pickle.get()
if plans is None:
plans = []
self.plans = plans
def __init__(self, file_location='data/passwords.pickle'):
super().__init__()
self.file_location = file_location
self.passwords_encrypted = None
self.password_loader = ObjectLoaderPickle(self.file_location)
self.password_validation_string_pickle_name = 'password_validation_string'
self.password_validation_string = SharedPreferences().get(
self.password_validation_string_pickle_name)
self.password_validation_magic_word = 'R U S Z A N I E'
self.main_password = None
self.__init()
def __init(self):
self.__add_command_parsers()
if self.storage_type == TaskStorageType.xml:
logging.debug("using xml file: " + self.task_file_location)
self.task_loader = TaskLoaderXml(self.task_file_location)
elif self.storage_type == TaskStorageType.pickle:
logging.debug("using pickle file: " + self.task_file_location)
self.task_loader = ObjectLoaderPickle(self.task_file_location)
else:
logging.error("Unrecognized storage type: '" +
str(self.storage_type.name) +
"' - using xml instead")
self.task_loader = TaskLoaderXml(self.task_file_location)
try:
self.tasks = self.task_loader.get()
except FileNotFoundError:
logging.info(self.task_file_location + " - file doesn't exist")
self.tasks = []
except TaskFileBrokenException as e:
print('Task file broken. Not saving changes!')
logging.error(self.task_file_location +
' - file broken. Not saving changes!')
self.tasks = e.args[0]
self.allowedToSaveTasks = False
self.periodic_task_generator = PeriodicTaskGenerator(
self.periodic_tasks_location, self.events_location)
self.periodic_task_progress_handler = PeriodicTaskProgressHandler(
self.periodic_tasks_location, self.events_location)
def test_note_add(self):
self.assertEqual(
os.path.isfile(ConfigLoader.get_mumjolandia_location() +
'data/notes.pickle'), False)
self.mumjolandia_starter.set_commands(
["note add 'test note'", "note add 'second test note'"])
with HiddenPrints():
self.mumjolandia_starter.run()
self.mumjolandia_starter.get_mumjolandia_thread().join()
self.assertEqual(
os.path.isfile(ConfigLoader.get_mumjolandia_location() +
'data/notes.pickle'), True)
note = ObjectLoaderPickle('data/notes.pickle').get()
self.assertEqual(len(note), 2)
self.assertEqual(str(note[0]), 'test note')
self.assertEqual(str(note[1]), 'second test note')
def __init__(self, file_location: str):
self.file_location = file_location
self.object_loader_pickle = ObjectLoaderPickle(self.file_location)
self.plans: [Plan] = [] # to avoid change date between 'get_id' and 'add' plans are saved to variable
class PasswordSupervisor(MumjolandiaSupervisor):
def __init__(self, file_location='data/passwords.pickle'):
super().__init__()
self.file_location = file_location
self.passwords_encrypted = None
self.password_loader = ObjectLoaderPickle(self.file_location)
self.password_validation_string_pickle_name = 'password_validation_string'
self.password_validation_string = SharedPreferences().get(
self.password_validation_string_pickle_name)
self.password_validation_magic_word = 'R U S Z A N I E'
self.main_password = None
self.__init()
def __init(self):
self.__add_command_parsers()
self.passwords_encrypted = self.password_loader.get()
if self.passwords_encrypted is None:
self.passwords_encrypted = []
def __add_command_parsers(self):
self.command_parsers['add'] = self.__command_add
self.command_parsers['get'] = self.__command_get
self.command_parsers['help'] = self.__command_help
self.command_parsers['init'] = self.__command_init
self.command_parsers['ls'] = self.__command_list
self.command_parsers['rm'] = self.__command_rm
self.command_parsers['set'] = self.__command_set
def __command_add(self, args):
if self.main_password is None:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_not_set)
if len(args) < 3:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_incorrect_value)
new_name = args[0]
new_username = args[1]
new_password = args[2]
password = PasswordFactory().get_password(self.main_password,
new_password, new_name,
new_username)
self.passwords_encrypted.append(password)
self.password_loader.save(self.passwords_encrypted)
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_add_ok,
arguments=[password.name])
def __command_get(self, args):
if self.main_password is None:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_not_set)
if len(args) < 1:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_incorrect_value,
arguments=[])
password = None
for p in self.passwords_encrypted:
if p.name == args[0]:
password = p
if password is None:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_incorrect_value,
arguments=[])
else:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_get_ok,
arguments=[
password.name,
PydesWrapper().decrypt(self.main_password,
password.username),
PydesWrapper().decrypt(self.main_password,
password.password)
])
def __command_help(self, args):
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_help,
arguments=[
'add [name]\n'
'get [name]\n'
'help\n'
'init [password]\n'
'ls\n'
'rm [name]\n'
'set [password]\n'
])
def __command_init(self, args):
if len(args) < 1:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_incorrect_value,
arguments=[])
validation_ok = self.__create_password_validation_string(args[0])
if validation_ok:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_set_ok)
else:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_incorrect_value)
def __command_list(self, args):
if self.main_password is None:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_not_set)
return_value = []
for p in self.passwords_encrypted:
return_value.append(p.name)
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_list_ok,
arguments=[return_value])
def __command_rm(self, args):
if self.main_password is None:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_not_set)
password = None
for p in self.passwords_encrypted:
if p.name == args[0]:
password = p
if password is None:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_incorrect_value,
arguments=[])
self.passwords_encrypted.remove(password)
self.password_loader.save(self.passwords_encrypted)
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_rm_ok, arguments=['ok'])
def __command_set(self, args):
if len(args) < 1:
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_incorrect_value,
arguments=[])
else:
if self.__check_password_validation_string(args[0]):
self.main_password = args[0]
else:
self.main_password = None
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_set_incorrect,
arguments=[args[0]])
return MumjolandiaResponseObject(
status=MumjolandiaReturnValue.password_set_ok)
def __create_password_validation_string(self, password):
self.password_validation_string = PydesWrapper().encrypt(
password, self.password_validation_magic_word)
if self.password_validation_string is not None:
SharedPreferences().put(
self.password_validation_string_pickle_name,
self.password_validation_string)
return True
return False
def __check_password_validation_string(self, password):
decrypted_magic_word = str(PydesWrapper().decrypt(
password, self.password_validation_string))
if self.password_validation_magic_word == decrypted_magic_word:
return True
return False
def __is_command_init_done(self):
if self.password_validation_string is not None:
return True
return False
def __init__(self, file_location):
super().__init__()
self.file_location = file_location
self.fat_loader = ObjectLoaderPickle(self.file_location)
self.fats = None
self.__init()
class FatSupervisor(MumjolandiaSupervisor):
def __init__(self, file_location):
super().__init__()
self.file_location = file_location
self.fat_loader = ObjectLoaderPickle(self.file_location)
self.fats = None
self.__init()
def get_fats(self):
return self.fats
def add_fat(self, value):
try:
self.fats.append(FatFactory.get_fat(value))
except IncorrectDateFormatException:
logging.warning("Fat '" + value + "' not added - incorrect date format")
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_incorrect_date_format)
except IncorrectVariableTypeException:
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_add_must_be_float)
logging.debug("Added '" + value + "'")
self.__save()
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_added, arguments=[value])
def delete_fat(self, fat_id):
# parameter comes as string. If we can parse it to int then we remove by id. If not, then by name
try:
fid = int(fat_id)
try:
self.fats.pop(fid)
self.__save()
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_delete_success,
arguments=[fat_id, str(1)])
except IndexError: # wrong index
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_delete_incorrect_index,
arguments=[fat_id])
except ValueError: # parameter type is not int
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_delete_incorrect_index,
arguments=[fat_id])
def __init(self):
self.__add_command_parsers()
self.fats = self.fat_loader.get()
def __save(self):
logging.debug("saving tasks to: '" + self.file_location + "'")
self.fat_loader.save(self.fats)
def __add_command_parsers(self):
self.command_parsers['add'] = self.__command_add
self.command_parsers['ls'] = self.__command_get
self.command_parsers['rm'] = self.__command_delete
def __command_add(self, args):
if len(args) < 1:
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_value_not_given)
else:
return self.add_fat(args[0])
def __command_get(self, args):
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_get_ok, arguments=self.fats)
def __command_delete(self, args):
try:
return self.delete_fat(args[0])
except IndexError:
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.fat_delete_incorrect_index,
arguments=['none'])
def __init__(self,
filename=ConfigLoader.get_mumjolandia_location() +
'data/shared_preferences.pickle'):
self.filename = filename
self.object_loader = ObjectLoaderPickle(self.filename)
class SharedPreferences:
def __init__(self,
filename=ConfigLoader.get_mumjolandia_location() +
'data/shared_preferences.pickle'):
self.filename = filename
self.object_loader = ObjectLoaderPickle(self.filename)
def get(self, name):
dictionary = self.__get_dict()
if dictionary is None:
return_value = None
else:
try:
return_value = dictionary[name]
except KeyError:
return_value = None
return return_value
def get_all(self):
return self.__get_dict()
def put(self, name, value):
dictionary = self.__get_dict()
if dictionary is None:
return_value = False
else:
dictionary[name] = value
self.object_loader.save(dictionary)
return_value = True
return return_value
def clear_key(self, key):
return_value = None
dictionary = self.__get_dict()
if dictionary is not None:
if dictionary.pop(key, None) is not None:
return_value = True
else:
return_value = False
if return_value:
self.object_loader.save(dictionary)
return return_value
def clear_starting_pattern(self, starting_pattern):
return_value = 0
dictionary = self.__get_dict()
if dictionary is not None:
for k in list(dictionary):
if k.startswith(starting_pattern):
del dictionary[k]
return_value += 1
if return_value != 0:
self.object_loader.save(dictionary)
return return_value
def __get_dict(self):
dictionary = self.object_loader.get()
if dictionary is None:
dictionary = {}
elif not isinstance(dictionary, dict):
logging.error('Could not load file as dictionary: "' +
self.filename + '"')
dictionary = None
return dictionary
class NoteSupervisor(MumjolandiaSupervisor):
def __init__(self, file_location):
super().__init__()
self.file_location = file_location
self.note_loader = ObjectLoaderPickle(self.file_location)
self.notes = None
self.__init()
def get_notes(self):
return self.notes
def add_note(self, name):
self.notes.append(NoteFactory.get_note(name))
self.__save()
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_add_ok, arguments=[name])
def delete_note(self, note_id):
try:
tid = int(note_id)
try:
self.notes.pop(tid)
self.__save()
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_delete_success,
arguments=[note_id, str(1)])
except IndexError: # wrong index
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_delete_incorrect_index,
arguments=[note_id])
except ValueError: # parameter type is not int
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_delete_incorrect_index,
arguments=[note_id])
def __init(self):
self.__add_command_parsers()
self.notes = self.note_loader.get()
if self.notes is None:
self.notes = []
def __save(self):
self.note_loader.save(self.notes)
def __add_command_parsers(self):
self.command_parsers['add'] = self.__command_add
self.command_parsers['ls'] = self.__command_get
self.command_parsers['rm'] = self.__command_delete
self.command_parsers['help'] = self.__command_help
def __command_add(self, args):
if len(args) < 1:
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_add_nook)
else:
return self.add_note(' '.join(args[0:]))
def __command_get(self, args):
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_get_ok, arguments=self.notes)
def __command_delete(self, args):
try:
return self.delete_note(args[0])
except IndexError:
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_delete_incorrect_index,
arguments=['none'])
def __command_help(self, args):
return MumjolandiaResponseObject(status=MumjolandiaReturnValue.note_help,
arguments=['ls\n'
'add [name]\n'
'rm [id]\n'])