def new_queue(request): user_storage = ORMUserStorage() user = user_storage.get_user_by_nick(request.user.username) if request.method != 'POST': form = QueueForm(user) else: form = QueueForm(user, data=request.POST) if form.is_valid(): user_storage = ORMUserStorage() queue_storage = ORMQueueStorage() queue_controller = QueueController(queue_storage) user_controller = UserController(user_storage) user = user_storage.get_user_by_nick(request.user.username) key = os.urandom(6).hex() queue = queue_controller.add_queue( name=form.cleaned_data['name'].upper(), key=key, owner=user) user_controller.link_user_with_queue(user, queue) return HttpResponseRedirect( reverse('web_tracker:show_queue', args=(key,))) context = {'form': form} return render(request, 'web_tracker/new_queue.html', context)
def notify(request): user_storage = ORMUserStorage() user = user_storage.get_user_by_nick(request.user.username) user_controller = UserController(user_storage) context = { 'messages': user.new_messages.split(','), 'notifications': user.notifications.split(',') } user_controller.clear_new_messages(user) return render(request, 'web_tracker/notify.html', context)
def register(request): if request.method != 'POST': form = UserCreationFormBoot() else: form = UserCreationFormBoot(data=request.POST) if form.is_valid(): user_storage = ORMUserStorage() user_controller = UserController(user_storage) queue_storage = ORMQueueStorage() queue_controller = QueueController(queue_storage) new_user = form.save() authenticated_user = authenticate( username=new_user.username, password=request.POST['password1'] ) user_controller.add_user( nick=new_user.username, uid=new_user.id ) user = user_storage.get_user_by_nick(nick=new_user.username) queue = queue_controller.add_queue(name='DEFAULT', key=os.urandom(6).hex(), owner=user) user_controller.link_user_with_queue(user, queue) login(request, authenticated_user) return HttpResponseRedirect(reverse('web_tracker:index')) context = {'form': form} return render(request, 'users/register.html', context)
def delete_queue(request, queue_key): queue_storage = ORMQueueStorage() queue = queue_storage.get_queue_by_key(queue_key) user_storage = ORMUserStorage() user = user_storage.get_user_by_uid(request.user.id) if queue.owner != user.uid: context = {'message': 'Access denied. You cannot delete this queue!'} return render(request, 'web_tracker/404.html', context) if queue.name == 'DEFAULT': context = {'message': 'Cannot delete default queue!'} return render(request, 'web_tracker/404.html', context) if queue.opened_tasks or queue.solved_tasks or queue.failed_tasks: task_storage = ORMTaskStorage() task_storage.delete_queue_tasks(queue) user_controller = UserController(user_storage) user_controller.unlink_user_and_queue(user, queue) queue_storage.remove_queue(queue) return HttpResponseRedirect(reverse('web_tracker:index'))
def wrapped_func(*args, **kwargs): task_storage = ORMTaskStorage() user_storage = ORMUserStorage() plan_storage = ORMPlanStorage() queue_storage = ORMQueueStorage() task_controller = TaskController(task_storage) user_controller = UserController(user_storage) plan_controller = PlanController(plan_storage) queue_controller = QueueController(queue_storage) interface = Interface('', queue_controller, user_controller, task_controller, plan_controller) interface.update_all() return func(*args, **kwargs)
def show_task(request, task_key): user_storage = ORMUserStorage() task_storage = ORMTaskStorage() user_controller = UserController(user_storage) user = user_storage.get_user_by_nick(request.user.username) task = task_storage.get_task_by_key(key=task_key) task.priority = TaskForm.priority_choices[task.priority] try: task.start = Time.get_date(task.start) except Exception: pass try: task.deadline = Time.get_date(task.deadline) except Exception: pass if not user_controller.can_show(user, task): context = {'message': 'Cannot edit see task: "{}", key {}!'.format( task.name, task_key) } return render(request, 'web_tracker/404.html', context) sub_tasks = task_storage.get_sub_tasks(task) parent_task = task_storage.get_task_by_key(task.parent) queue_storage = ORMQueueStorage() queue = queue_storage.get_queue_by_key(task.queue) can_edit = user_controller.can_edit(user, task) can_show_parent = user_controller.can_show_parent(user, parent_task) context = {'task': task, 'sub_tasks': sub_tasks, 'parent_task': parent_task, 'queue': queue, 'can_edit': can_edit, 'can_show_parent': can_show_parent } return render(request, 'web_tracker/show_task.html', context)
def run() -> int: """ Start program :return: int - exit code """ # check settings Configuration.apply_settings() set_logger_enabled(Configuration.is_logger_enabled()) # check for files and create it if they missed check_program_data_files(Files.FOLDER, Files.FILES) # set logging configuration if os.path.exists(Files.LOG_CONFIG): set_logger_config_file(Files.LOG_CONFIG) else: set_logger_config_file(Files.DEFAULT_LOG_CONFIG_FILE) # create loggers and cli_logger = get_logger() cli_logger.info('Start program.') # load data from storage and create entities controllers users_wrapper_storage = UserWrapperStorage(Files.AUTH_FILE, Files.ONLINE) queue_storage = JsonQueueStorage(Files.QUEUES_FILE) queue_controller = QueueController(queue_storage) task_storage = JsonTaskStorage(Files.TASKS_FILE) task_controller = TaskController(task_storage) user_storage = JsonUserStorage(Files.USERS_FILE) user_controller = UserController(user_storage) plan_storage = JsonPlanStorage(Files.PLANS_FILE) plan_controller = PlanController(plan_storage) # init library interface library = Interface(users_wrapper_storage.online_user, queue_controller, user_controller, task_controller, plan_controller) # update reminders deadlines queue and other library.update_all() _show_new_messages(library) parser = get_parsers() args = vars(parser.parse_args()) cli_logger.debug('Console args: {}'.format(args)) # check that target is defined target = args.pop(ParserArgs.TARGET.name) if target is None: parser.error('target is required', need_to_exit=False) return ERROR_CODE if target == ParserArgs.UPDATE.name: return 0 # check that action is defined action = args.pop(ParserArgs.ACTION) if action is None: FormattedParser.active_sub_parser.error('action is required', need_to_exit=False) return ERROR_CODE # check that target is config and do action with it if target == ParserArgs.CONFIG.name: if action == ParserArgs.SET: return _set_configuration(args) if action == ParserArgs.RESET: conf_type_obj = args.pop(ParserArgs.CONFIG_TYPE.name) return _reset_configuration(conf_type_obj) # check that target is user and do action with it if target == ParserArgs.USER.name: if action == ParserArgs.ADD: return _add_user(nick=args.pop(ParserArgs.NICKNAME.name), password=args.pop(ParserArgs.PASSWORD.name), users_storage=users_wrapper_storage, library=library) if action == ParserArgs.LOGIN.name: return _login(nick=args.pop(ParserArgs.NICKNAME.name), password=args.pop(ParserArgs.PASSWORD.name), users_storage=users_wrapper_storage, library=library) if action == ParserArgs.LOGOUT.name: return _logout(users_wrapper_storage) if action == ParserArgs.SHOW: long = args.pop(ParserArgs.LONG.dest) sortby = args.pop(ParserArgs.SORT_BY.dest) return _show_user_tasks(library, long, sortby) # check that target is queue and do action with it if target == ParserArgs.QUEUE.name: if action == ParserArgs.ADD: return _add_queue(name=args.pop( ParserArgs.QUEUE_NAME.name).strip(' '), library=library) if action == ParserArgs.DELETE: return _del_queue(key=args.pop( ParserArgs.QUEUE_NAME.name).strip(' '), recursive=args.pop(ParserArgs.RECURSIVE.dest), library=library) if action == ParserArgs.SET: key = args.pop(ParserArgs.KEY.name) new_name = args.pop(ParserArgs.NEW_NAME.dest) if new_name is None: parser.active_sub_parser.help() return 0 return _edit_queue(key=key, new_name=new_name, library=library) if action == ParserArgs.SHOW: return _show_queue_tasks( key=args.pop(ParserArgs.KEY.name), opened=args.pop(ParserArgs.OPEN_TASKS.dest), archive=args.pop(ParserArgs.SOLVED_TASKS.dest), failed=args.pop(ParserArgs.FAILED_TASKS.dest), long=args.pop(ParserArgs.LONG.dest), library=library, sortby=args.pop(ParserArgs.SORT_BY.dest)) if action == ParserArgs.FIND: name = args.pop(ParserArgs.QUEUE_NAME.name) return _find_queues(name, library) # check that target is task and do action with it if target == ParserArgs.TASK.name: if action == ParserArgs.ADD: return _add_task(args, library) if action == ParserArgs.SET: return _edit_task(args, library) if action == ParserArgs.DELETE: return _del_task(args, library) if action == ParserArgs.SHOW: return _show_task(args.pop(ParserArgs.KEY.name), library, args.pop(ParserArgs.LONG.dest)) if action == ParserArgs.FIND: return _find_task(args, library) if action == ParserArgs.ACTIVATE: key = args.pop(ParserArgs.KEY.name) return _activate_task(key, library) # check that target is plan and do action with it if target == ParserArgs.PLAN.name: if action == ParserArgs.ADD: name = args.pop(ParserArgs.PLAN_NAME.name) period = args.pop(ParserArgs.PLAN_PERIOD.name) activation_time = args.pop(ParserArgs.PLAN_ACTIVATION_TIME.name) reminder = args.pop(ParserArgs.TASK_REMINDER.dest) return _add_plan(name, activation_time, period, reminder, library) if action == ParserArgs.SET: key = args.pop(ParserArgs.KEY.name) new_name = args.pop(ParserArgs.PLAN_NAME_OPTIONAL.dest) period = args.pop(ParserArgs.PLAN_PERIOD_OPTIONAL.dest) activation_time = args.pop( ParserArgs.PLAN_ACTIVATION_TIME_OPTIONAL.dest) reminder = args.pop(ParserArgs.TASK_REMINDER.dest) return _edit_plan(key, new_name, period, activation_time, reminder, library) if action == ParserArgs.SHOW: return _show_plans(library) if action == ParserArgs.DELETE: key = args.pop(ParserArgs.KEY.name) return _delete_plan(key, library) if target == ParserArgs.NOTIFICATIONS.name: if action == ParserArgs.SHOW: notifications = library.online_user.notifications print('Notifications for user "{}":'.format( library.online_user.nick)) if _show_messages(notifications): print('Notifications not found!') library.clear_new_messages() if action == ParserArgs.DELETE: _del_notifications(library, _all=args.pop(ParserArgs.ALL.dest), old=args.pop(ParserArgs.OLD.dest))
def setUp(self): self.storage = TestUserStorage([]) self.controller = UserController(self.storage)
class UserTests(TestCase): def setUp(self): self.storage = TestUserStorage([]) self.controller = UserController(self.storage) def test_add_user(self): user = self.controller.add_user(nick='tester', uid=0) self.assertIn(user, self.storage.users) def test_find_user_by_nick(self): user_1 = self.controller.add_user(nick='user 1', uid=0) igor = self.controller.add_user(nick='igor', uid=1) vanya = self.controller.add_user(nick='vanya', uid=2) found = self.controller.find_user(nick='igor') self.assertEqual(igor, found) def test_find_user_by_uid(self): user_1 = self.controller.add_user(nick='user 1', uid=0) igor = self.controller.add_user(nick='igor', uid=1) vanya = self.controller.add_user(nick='vanya', uid=2) found = self.controller.find_user(uid=2) self.assertEqual(vanya, found) def test_clear_user_notifications(self): user = self.controller.add_user(nick='tester', uid=0) user.notifications.append('Hello') user.notifications.append('I need to work') user.notifications.append('Go home') self.controller.clear_user_notifications(user) self.assertListEqual(user.notifications, []) def test_clear_user_2_old_notifications(self): user = self.controller.add_user(nick='tester', uid=0) user.notifications.append('Hello') user.notifications.append('I need to work') user.notifications.append('Go home') self.controller.clear_user_notifications(user, 2) self.assertListEqual(user.notifications, ['Go home']) def test_clear_new_messages(self): user = self.controller.add_user(nick='tester', uid=0) user.notifications.append('other notification') user.new_messages.append('1 new notify') user.new_messages.append('2 new notify') self.controller.clear_new_messages(user) self.assertListEqual(user.notifications, ['other notification', '1 new notify', '2 new notify']) self.assertListEqual(user.new_messages, []) def test_notify_user(self): user = self.controller.add_user(nick='tester', uid=0) self.controller.notify_user(user, 'privet', show_time=False) self.controller.notify_user(user, 'with time') expected_str = ''.join([dt.now().strftime(Time.EXTENDED_TIME_FORMAT), ': ', 'with time']) self.assertListEqual(user.new_messages, ['privet', expected_str]) def test_link_user_with_queue(self): user = self.controller.add_user(nick='tester', uid=0) queue = Queue('test queue', key='0', owner=user.nick) self.controller.link_user_with_queue(user, queue) self.assertListEqual(user.queues, ['0']) def test_unlink_user_with_queue(self): user = self.controller.add_user(nick='tester', uid=0) queue = Queue('test queue', key='0', owner=user.nick) self.controller.link_user_with_queue(user, queue) self.controller.unlink_user_and_queue(user, queue) self.assertListEqual(user.queues, []) def test_link_responsible_with_task(self): owner = self.controller.add_user(nick='owner', uid=0) responsible = self.controller.add_user(nick='responsible', uid=1) task = Task(name='Test task', key='3453', author=owner.nick) self.controller.link_responsible_with_task(responsible, task) self.assertListEqual(responsible.tasks_responsible, ['3453']) def test_unlink_responsible_with_task(self): owner = self.controller.add_user(nick='owner', uid=0) responsible = self.controller.add_user(nick='responsible', uid=1) task = Task(name='Test task', key='3453', author=owner.nick) self.controller.link_responsible_with_task(responsible, task) self.controller.unlink_responsible_and_task(responsible, task) self.assertListEqual(responsible.tasks_responsible, []) def test_link_author_with_task(self): owner = self.controller.add_user(nick='owner', uid=0) task = Task(name='Test task', key='3453', author=owner.nick) self.controller.link_author_with_task(owner, task) self.assertListEqual(owner.tasks_author, ['3453']) def test_unlink_author_with_task(self): owner = self.controller.add_user(nick='owner', uid=0) task = Task(name='Test task', key='3453', author=owner.nick) self.controller.link_author_with_task(owner, task) self.controller.unlink_author_and_task(owner, task) self.assertListEqual(owner.tasks_author, [])
def new_task(request): user_storage = ORMUserStorage() user = user_storage.get_user_by_nick(nick=request.user.username) if request.method != 'POST': form = TaskForm(user) else: form = TaskForm(user, data=request.POST) if form.is_valid(): creating_time = dt.strftime(dt.now(), Time.EXTENDED_TIME_FORMAT) task_storage = ORMTaskStorage() task_controller = TaskController(task_storage) user_controller = UserController(user_storage) queue_storage = ORMQueueStorage() queue_controller = QueueController(queue_storage) queue = queue_storage.find_queue(key=form.cleaned_data['queue'], owner=user) resp = form.cleaned_data['responsible'] responsible_users = ','.join(resp) start = form.cleaned_data['start'] deadline = form.cleaned_data['deadline'] try: Time.get_date(start) except Exception: start = '' try: Time.get_date(deadline) except Exception: deadline = '' key = os.urandom(8).hex() try: task = task_controller.add_task( name=form.cleaned_data['name'], description=form.cleaned_data['description'], queue=queue, parent=form.cleaned_data['parent'], related=form.cleaned_data['related'], responsible=responsible_users, priority=form.cleaned_data['priority'], progress=form.cleaned_data['progress'], start=start, deadline=deadline, tags=form.cleaned_data['tags'], reminder=form.cleaned_data['reminder'], key=key, author=user, creating_time=creating_time ) except AppError as e: form.add_error('name', e.message) context = {'form': form} return render(request, 'web_tracker/new_task.html', context) user_controller.link_author_with_task(user, task) for user_nick in resp: user = user_storage.get_user_by_nick(user_nick) user_controller.link_responsible_with_task(user, task) queue_controller.link_queue_with_task(queue, task) return HttpResponseRedirect( reverse('web_tracker:show_task', args=(key,))) context = {'form': form} return render(request, 'web_tracker/new_task.html', context)