def remove_from_project_by_id(self, uid, pid):
"""
This function removes user from the project by it's id
:param pid: Project's id
:param uid: User's id
:return: None
"""
try:
# we get task where current user is admin and where project id is
# matching
Project.select().where(
(self.uid == Project.admin) & (Project.pid == pid)).get()
logger.debug('such project exists')
# if an admin tries to delete himself we deny it
if uid == self.uid:
raise db_e.InvalidPidError(
db_e.ProjectMessages.DO_NOT_HAVE_RIGHTS)
except DoesNotExist:
# not admin can try to delete himself
if uid != self.uid:
raise db_e.InvalidPidError(
db_e.ProjectMessages.DO_NOT_HAVE_RIGHTS)
# now we try to find and delete user
rows = UserProjectRelation.delete().where(
(UserProjectRelation.project == pid) &
(UserProjectRelation.user == uid)).\
execute()
if rows == 0:
raise db_e.InvalidUidError(db_e.LoginMessages.NO_USER_TO_DELETE)
def _init_project_table():
for project in _PROJECTS:
Project.create(admin=project.admin_uid,
description=project.description,
title=project.title)
UserProjectRelation.create(user=project.admin_uid, project=project.pid)
# add another members relations
for relation in _USER_PROJECT_RELATIONS:
UserProjectRelation.create(user=relation['user_id'],
project=relation['project_id'])
def _get_available_projects(self):
# get all tasks in project related to user
query_projects = Project.select(). \
join(UserProjectRelation).\
where(UserProjectRelation.user == self.uid)
return query_projects
def get_project_by_id(self, pid):
"""
This function finds project by id and current user in database and
returns it or raise error due to incorrect request
:param pid: Project id to find
:type pid: Int
:return: Project
"""
try:
# we are checking if there is a connection our user and selected
# project
UserProjectRelation.select(). \
where((UserProjectRelation.user == self.uid) &
(UserProjectRelation.project == pid)).get()
# if so, ge get this project by pid
project = Project.select().where((Project.pid == pid))
return ProjectInstance.make_project(project.get())
except DoesNotExist:
logger.info('There is no such pid %s in the database for your user',
pid)
raise db_e.InvalidPidError(
db_e.ProjectMessages.PROJECT_DOES_NOT_EXISTS)
def save(self, obj):
"""
This function is used to store given project in database
:param obj: type with fields:
- pid
- admin_uid
- description
- title
:return: None
"""
try:
if not self.has_rights(obj.pid):
raise db_e.InvalidLoginError(
db_e.ProjectMessages.DO_NOT_HAVE_RIGHTS)
project = Project.select().where(Project.pid == obj.pid).get()
self._update(project, obj)
return
except db_e.InvalidPidError:
logger.debug('adding project...')
try:
project = Project(admin=obj.admin_uid,
description=obj.description,
title=obj.title)
relation = UserProjectRelation(user=self.uid,
project=project)
# only if everything is ok we try save project to our database
project.save()
relation.save()
except IntegrityError:
# if you are guest
raise db_e.InvalidLoginError(
db_e.ProjectMessages.DO_NOT_HAVE_RIGHTS)
logger.debug('project saved to database')
def has_rights(self, pid):
"""
This function checks if logged user has rights to do something inside
the project (except deleting and modifying his own tasks)
:param pid: Project's id
:return: Bool
"""
try:
Project.select().where(Project.pid == pid).get()
except DoesNotExist:
raise db_e.InvalidPidError(
db_e.ProjectMessages.PROJECT_DOES_NOT_EXISTS)
try:
Project.select().where((Project.pid == pid) &
(Project.admin == self.uid)).get()
return True
except DoesNotExist:
return False
def remove_project_by_id(self, pid):
"""
This function removes project from id snd clears all relations between
users and passed project. Or it raises an exception if you don't have
rights or pid do not exists
:param pid: Project's id
:return: None
"""
if not self.has_rights(pid):
raise db_e.InvalidLoginError(
db_e.ProjectMessages.DO_NOT_HAVE_RIGHTS)
try:
UserProjectRelation.delete(). \
where(UserProjectRelation.project == pid).execute()
Task.delete().where(Task.project == pid).execute()
Project.delete().where(Project.pid == pid).execute()
logger.debug('project fully removed')
except DoesNotExist:
db_e.InvalidPidError(db_e.ProjectMessages.PROJECT_DOES_NOT_EXISTS)
def last_id():
"""
This function gets last id to add project on it's place
TODO:
This function finds the first unused id in the table to add new project
row on that place
:return: Int
"""
query = Project.select().order_by(Project.pid.desc())
logger.debug('getting last id from query...')
try:
# project query
return query.get().pid
except DoesNotExist:
return 0
def add_user_to_project_by_id(self, uid, pid):
"""
This function adds user to the Project relationship table to make user a
member of the project, if both exists.
:param uid: User's id
:param pid: Project's id
:return: None
"""
try:
# we get task where current user is admin and where project id is
# matching
project = Project.select(). \
where((self.uid == Project.admin) &
(Project.pid == pid)).get()
logger.debug('such project exists')
except DoesNotExist:
raise db_e.InvalidPidError(
db_e.ProjectMessages.DO_NOT_HAVE_RIGHTS)
# NOTE: due to we don't have access to the users db, we BELIEVE, that
# user exists in the database (you should check that on the auth level)
try:
# and now we are checking if selected user already in the project.
# If the exception DoesNotExist was not raised, that means that user
# already in project and it's bad
UserProjectRelation.select(). \
where((UserProjectRelation.project == pid) &
(UserProjectRelation.user == uid)).get()
logger.debug('such relation exists')
raise db_e.InvalidLoginError(
db_e.ProjectMessages.USER_ALREADY_EXISTS)
except DoesNotExist:
logger.debug('such user is not in project')
UserProjectRelation.create(user=uid, project=project)
logger.info('user_project relation created')
def has_rights(self, tid):
"""
This function returns bool value for current user. It checks if he can
modify this task or not
:param tid: Task's id
:return: Bool
"""
try:
task = Task.select().where(Task.tid == tid).get()
except DoesNotExist:
raise db_e.InvalidTidError(db_e.TaskMessages.TASK_DOES_NOT_EXISTS)
if task.receiver == self.uid:
return True
elif task.project:
project = Project.select().where(Project.pid == task.project).get()
return project.admin == self.uid
else:
return task.creator == self.uid