class JsonQueueStorage(IQueueStorage):
"""This class represent instance for store queues in json format"""
def __init__(self, path_to_queue_file):
self.queue_db = JsonDatabase(path_to_queue_file, cls_seq=[Queue])
super().__init__(self.queue_db.load())
def save_queues(self):
"""
This method unload queue in json database
:return: None
"""
self.queue_db.unload(self.queues)
def add_queue(self, queue):
"""
This method append queue in list of queues
:param queue for adding
:return: added queue
"""
self.queues.append(queue)
def remove_queue(self, queue):
"""
This method remove queue from storage
:param queue: queue for removing
:return: None
"""
self.queues.remove(queue)
def get_queue_by_key(self, key):
"""
This method using for getting queue by key
:param key: access key
:return: queried queue
"""
for queue in self.queues: # type: Queue
if key == queue.key:
return queue
def get_queue_by_name(self, name):
"""
This method using for getting queue by key
:param name: queue name
:return: queried queue
"""
for queue in self.queues:
if name == queue.name:
return queue
def get_user_default_queue(self, user):
"""
This method using for getting default queue from storage for user
:param user: user for getting queue
:return: queried queue
"""
for queue in self.queues:
if queue.owner == user.uid:
if queue.name == Constants.DEFAULT_QUEUE:
return queue
class JsonUserStorage(IUserStorage):
"""This class represent instance for storing users in
file in json format"""
def __init__(self, users_file):
self.users_db = JsonDatabase(users_file, [User])
super().__init__(self.users_db.load())
def get_user_by_nick(self, nick):
"""
This method getting user from database by his nick
:param nick: parametr for finding
:return: user which has suitable nick
"""
for user in self.users:
if user.nick == nick:
return user
def get_user_by_uid(self, uid):
"""
This method using for getting user from database by his uid
:param uid: user universal identifier
:return: requested user
"""
for user in self.users:
if user.uid == uid:
return user
def save_users(self):
"""
This method save user in database
:return: None
"""
self.users_db.unload(self.users)
def add_user(self, user):
"""
This method append user in users list
:param user: added user
:return: None
"""
self.users.append(user)
class JsonPlanStorage(IPlanStorage):
"""This class implement IPlanStorage interface and represent instance
which store plans in file in json format"""
def __init__(self, path_to_plans_file):
self.plans_db = JsonDatabase(path_to_plans_file, cls_seq=[Plan])
super().__init__(self.plans_db.load())
def add_plan(self, plan):
"""
This method add plan in plan storage
:param plan: added plan
:return: None
"""
self.plans.append(plan)
def remove_plan(self, plan):
"""
This method remove plan from plan storage
:param plan:
:return: None
"""
self.plans.remove(plan)
def save_plans(self):
"""
This method unload plans in database
:return: None
"""
self.plans_db.unload(self.plans)
def get_plan_by_key(self, key):
"""
This module find in plan storage task by key
:param key: plan access key
:return: queried plan
"""
for plan in self.plans:
if plan.key == key:
return plan
def __init__(self, path_to_plans_file):
self.plans_db = JsonDatabase(path_to_plans_file, cls_seq=[Plan])
super().__init__(self.plans_db.load())
def __init__(self, users_wrapper_file, online_user_file):
self.online_user_db = JsonDatabase(online_user_file, [])
self.users_wrapper_db = JsonDatabase(users_wrapper_file, [UserWrapper])
self.users = self.users_wrapper_db.load()
self.__online_user = self.online_user_db.load()
class UserWrapperStorage:
"""
Store in database all user wrappers
"""
def __init__(self, users_wrapper_file, online_user_file):
self.online_user_db = JsonDatabase(online_user_file, [])
self.users_wrapper_db = JsonDatabase(users_wrapper_file, [UserWrapper])
self.users = self.users_wrapper_db.load()
self.__online_user = self.online_user_db.load()
@log_cli
def add_user(self, nick, password):
"""
Function for add user to database
:param nick:
:param password:
:return: None
"""
if nick == 'guest':
raise SaveUserError('name "guest" booked by program')
for user in self.users:
if user.nick == nick:
raise SaveUserError('user "{}" already exists'.format(nick))
self.users.append(UserWrapper(nick, password))
self.record_users()
@log_cli
def record_users(self):
"""
Record users to database
:return: None
"""
self.users_wrapper_db.unload(self.users)
@property
def online_user(self):
"""
Get online user
:return: online user
"""
return self.__online_user
@online_user.setter
def online_user(self, user=None):
"""
Set online user
:param user:
:return: None
"""
if user is None:
self.online_user_db.unload("")
else:
self.online_user_db.unload(user.nick)
@log_cli
def get_user(self, query: UserWrapper):
"""
Get user by query
:param query:
:return: user
"""
for user in self.users:
if user == query:
return user
class JsonTaskStorage(ITaskStorage):
"""
This class using for store all tasks in one place in json format
"""
def __init__(self, path_to_tasks_file):
self.tasks_db = JsonDatabase(path_to_tasks_file, [Task])
super().__init__(self.tasks_db.load())
def add_task(self, task):
"""This method append task to tasks list
:param: task: task for adding
:return: None
"""
self.tasks.append(task)
def remove_task(self, task):
"""
This method using for deleting task from task storage
:param task: task for removing
:return: None
"""
self.tasks.remove(task)
def get_sub_tasks(self, task: Task):
"""
This method using for getting task sub tasks
:param task: parent task which has sub tasks
:return: sub tasks
"""
sub_tasks = []
for sub_task_key in task.sub_tasks:
sub_task = self.get_task_by_key(sub_task_key)
sub_tasks.append(sub_task)
return sub_tasks
def get_task_by_key(self, key):
"""
This method using for getting task by key from task storage
:param key: access key
:return: queried task
"""
for task in self.tasks:
if task.key == key:
return task
def get_task_by_name(self, name):
"""
This method using for getting task by name from task storage
:param name: task name
:return: queried task
"""
tasks = []
for task in self.tasks:
if task.name == name or task.name.startswith(name):
tasks.append(task)
return tasks
def get_task_by_tag(self, tag):
"""
This method using for getting task by tag from task storage
:param tag: task tag
:return: tasks with tag
"""
tasks = []
for task in self.tasks:
if task.tags and tag in task.tags:
tasks.append(task)
return tasks
def save_tasks(self):
"""
This method using for save task in database
:return: None
"""
self.tasks_db.unload(self.tasks)
def __init__(self, path_to_tasks_file):
self.tasks_db = JsonDatabase(path_to_tasks_file, [Task])
super().__init__(self.tasks_db.load())
def __init__(self, users_file):
self.users_db = JsonDatabase(users_file, [User])
super().__init__(self.users_db.load())
def __init__(self, path_to_queue_file):
self.queue_db = JsonDatabase(path_to_queue_file, cls_seq=[Queue])
super().__init__(self.queue_db.load())