Example #1
0
def detail(request, task_id):

    current_user = request.user

    controller = TaskController(current_user.id)
    comment_controller = CommentController(current_user.id)

    task = controller.get_task_by_id(task_id=task_id)
    comment_list = comment_controller.get_task_comments(task_id=task_id)

    user_list = []
    for user in task['users']:
        user_list.append(User.objects.get(id=user))

    owner = task['creator']

    try:
        owner = User.objects.get(id=owner)
    except:
        raise Exception()
    print(owner)
    return render(
        request, 'tasks/detail.html', {
            'task': task,
            'comment_list': comment_list,
            'user_list': user_list,
            'owner': owner
        })
Example #2
0
def edit(request, task_id):
    # if this is a POST request we need to process the form data

    current_user = request.user
    controller = TaskController(current_user.id)
    task = controller.get_task_by_id(task_id)

    if request.method == 'POST':
        # create a form instance and populate it with data from the request:
        form = TaskForm(request.POST)
        # check whether it's valid:

        if form.is_valid():
            data = form.cleaned_data
            controller.edit_task(
                task_id, {
                    'title': data['title'],
                    'text': data['text'],
                    'status': data['status'],
                    'tags': data['tags']
                })
            return HttpResponseRedirect('/tasks')

    # if a GET (or any other method) we'll create a blank form
    else:
        form = TaskForm(data=task)

    return render(request, 'tasks/edit-task.html', {
        'form': form,
        'task': task
    })
Example #3
0
def comment(request, task_id):
    current_user = request.user

    controller = TaskController(current_user.id)
    comment_controller = CommentController(current_user.id)

    controller.get_task_by_id(task_id=task_id)
    comment = comment_controller.create_task_comment(
        task_id=task_id, text=request.POST.get('text'))
    return HttpResponseRedirect('/tasks/{}/'.format(task_id))
Example #4
0
def toggle_task_completion(request, task_id):
    current_user = request.user
    controller = TaskController(current_user.id)
    task = controller.get_task_by_id(task_id)

    if task['status'] == TaskStatus.PLANNED.value:
        new_status = TaskStatus.COMPLETED.value
    else:
        new_status = TaskStatus.PLANNED.value
    controller.edit_task(task_id=task_id,
                         edited_task={'status': str(new_status)})
    return JsonResponse({'success': True})
Example #5
0
def share_permission(request, task_id):
    current_user = request.user
    try:
        user = User.objects.get(username=request.POST.get('user'))
    except User.DoesNotExist:
        return JsonResponse({
            'success': False,
            'message': 'User not found',
            'url': '/tasks/{}/'.format(task_id),
        })

    controller = TaskController(current_user.id)
    controller.share_permission(new_user_id=user.id, task_id=task_id)
    return JsonResponse({
        'success': True,
        'url': '/tasks/{}/'.format(task_id),
    })
Example #6
0
def index(request):
    current_user = request.user

    controller = TaskController(current_user.id)
    tasks = controller.get_tasks()

    tags = set()
    for task in tasks:
        if task['tags']:
            tags.update(map(lambda tag: tag.strip(), task['tags'].split(',')))

    for task in tasks:
        task['subtasks'] = controller.get_task_subtasks(task['id'])

    if request.is_ajax():
        active_tag = request.GET.get('active_tag')
        req_period = request.GET.get('period')

        if active_tag:
            if active_tag != 'all':
                tasks = controller.get_tasks_by_tag(active_tag)
            return render(request, 'tasks/tasks-list.html', {
                'tasks': tasks,
                'tags': tags
            })

        if req_period:
            res_tasks = []
            result_tasks = []
            date_tasks_list = controller.get_tasks_on_period(
                periods[req_period][0].strftime('%d/%m/%y'),
                periods[req_period][1].strftime('%d/%m/%y'))

            #get all tasks
            for date_tasks in date_tasks_list:
                date = list(date_tasks.keys())[0]
                for task in date_tasks[date]:
                    res_tasks.append(task)

            #remove duplicate
            for res_task in res_tasks:
                is_dublicate = False
                for res in result_tasks:
                    if res_task['id'] == res['id']:
                        is_dublicate = True

                if not is_dublicate:
                    result_tasks.append(res_task)
                else:
                    is_dublicate = False

            for task in result_tasks:
                task['subtasks'] = controller.get_task_subtasks(task['id'])

            return render(request, 'tasks/tasks-list.html', {
                'tasks': result_tasks,
                'tags': tags
            })

    return render(request, 'tasks/index.html', {'tasks': tasks, 'tags': tags})
Example #7
0
def create_subtask(request, task_id):
    current_user = request.user
    controller = TaskController(current_user.id)

    if request.method == 'POST':
        form = TaskForm(request.POST)

        if form.is_valid():
            data = form.cleaned_data
            if data['period'] and data['start_date']:
                controller.create_periodic_task(
                    data['title'],
                    data['text'],
                    data['status'],
                    tags=data['tags'],
                    start_date=data['start_date'].strftime('%d/%m/%y %H:%M')
                    if data['start_date'] else None,
                    deadline=data['date'].strftime('%d/%m/%y %H:%M')
                    if data['date'] else None,
                    period=data['period'],
                    parent_id=task_id)
            else:
                controller.create_task(
                    data['title'],
                    data['text'],
                    data['status'],
                    tags=data['tags'],
                    date=data['date'].strftime('%d/%m/%y %H:%M')
                    if data['date'] else None,
                    parent_id=task_id)
            return HttpResponseRedirect('/tasks')

    else:
        form = TaskForm()

    return render(request, 'tasks/create-subtask.html', {
        'form': form,
        'task_id': task_id
    })
Example #8
0
def create(request):
    current_user = request.user

    controller = TaskController(current_user.id)

    if request.method == 'POST':
        form = TaskForm(request.POST)

        if form.is_valid():
            data = form.cleaned_data
            if data['period'] and data['start_date']:
                controller.create_periodic_task(
                    data['title'],
                    data['text'],
                    data['status'],
                    tags=data['tags'],
                    start_date=data['start_date'].strftime('%d/%m/%y %H:%M')
                    if data['start_date'] else None,
                    deadline=data['date'].strftime('%d/%m/%y %H:%M')
                    if data['date'] else None,
                    period=data['period'])
            else:
                controller.create_task(
                    data['title'],
                    data['text'],
                    data['status'],
                    tags=data['tags'],
                    date=data['date'].strftime('%d/%m/%y %H:%M')
                    if data['date'] else None,
                )
            return HttpResponseRedirect('/tasks')

    # if a GET (or any other method) we'll create a blank form
    else:
        form = TaskForm()

    return render(request, 'tasks/task-create.html', {'form': form})
Example #9
0
class CommentControllerTest(unittest.TestCase):
    def setUp(self):
        self.controller = CommentController(user_id=1)
        self.task_controller = TaskController(user_id=1)

    def test_get_comment(self):
        task = {'title': '__test__ title', 'text': '__test__ text', 'status': 1}
        created_task = self.task_controller.create_task(task['title'], task['text'], task['status'])
        self.controller.create_task_comment(task_id=created_task.id, text="TEXT")
        comments = self.controller.get_task_comments(task_id=created_task.id)
        self.assertIn("TEXT", comments[0]['text'])
        self.task_controller.delete_task(created_task.id)

    def test_create_comment(self):
        task = {'title': '__test__ title', 'text': '__test__ text', 'status': 1}
        created_task = self.task_controller.create_task(task['title'], task['text'], task['status'])
        comment = self.controller.create_task_comment(task_id=created_task.id, text="lala")
        comments = self.controller.get_task_comments(task_id=created_task.id)
        self.assertIsInstance(comments, list)
        self.task_controller.delete_task(created_task.id)

    def test_check_user_commentw(self):
        with self.assertRaises(errs.CommentNotFoundError):
            self.controller.check_user_in_comment(user_id=1, comment_id=1777)
Example #10
0
 def setUp(self):
     self.controller = TaskController(user_id=1)
Example #11
0
class TaskControllerTestCase(unittest.TestCase):
    def setUp(self):
        self.controller = TaskController(user_id=1)

    def test_create_task(self):
        task = {
            'title': '__test__ title',
            'text': '__test__ text',
            'status': 1
        }
        created_task = self.controller.create_task(task['title'], task['text'],
                                                   task['status'])
        self.assertEqual(task['title'], created_task.title)
        self.assertEqual(task['text'], created_task.text)
        self.assertEqual(task['status'], created_task.status)
        self.controller.delete_task(created_task.id)

    def test_create_periodic_task(self):
        task = {
            'title': '__test__ title',
            'text': '__test__ text',
            'status': 1,
            'start_date': '31/12/98 00:00',
            'deadline': '31/12/02 00:00',
            'period': '* * * * *',
            'tags': "test_love"
        }
        created_task = self.controller.create_periodic_task(
            title=task['title'],
            text=task['text'],
            status=task['status'],
            start_date=task['start_date'],
            deadline=task['deadline'],
            period=task['period'],
            tags=task['tags'])
        self.assertEqual(task['title'], created_task.title)
        self.assertEqual(task['text'], created_task.text)
        self.assertEqual(task['status'], created_task.status)
        self.assertEqual(task['period'], created_task.period)

    def test_check_permisson(self):
        with self.assertRaises(errs.TaskNotExistError):
            self.controller.check_permission(user_id=45, task_id=1111)

    def test_get_task_by_id(self):
        task = {
            'title': '__test__ title',
            'text': '__test__ text',
            'status': 1
        }
        created_task = self.controller.create_task(task['title'], task['text'],
                                                   task['status'])
        task = self.controller.get_task_by_id(task_id=created_task.id)
        self.assertEqual(task['id'], created_task.id)
        self.controller.delete_task(created_task.id)

    def test_edit_title(self):  ###########3
        task = {
            'title': '__test__ title',
            'text': '__test__ text',
            'status': 1
        }
        created_task = self.controller.create_task(task['title'], task['text'],
                                                   task['status'])
        task = self.controller.edit_task(created_task.id, {'title': 'NEW'})
        self.assertNotEqual(created_task.title, "NEW")
        self.controller.delete_task(created_task.id)

    def test_edit_text(self):
        task = {
            'title': '__test__ title',
            'text': '__test__ text',
            'status': 1
        }
        created_task = self.controller.create_task(task['title'], task['text'],
                                                   task['status'])
        task = self.controller.edit_task(created_task.id, {'text': "lol"})
        self.assertNotEqual(created_task.status, "RARA")
        self.controller.delete_task(created_task.id)

    def test_get_subtasks(self):
        task = {
            'title': '__test__ title',
            'text': '__test__ text',
            'status': 1
        }
        created_task = self.controller.create_task(task['title'], task['text'],
                                                   task['status'])
        subtask = self.controller.create_task(task['title'],
                                              task['text'],
                                              task['status'],
                                              parent_id=created_task.id)
        task_subtasks = self.controller.get_task_subtasks(
            task_id=created_task.id)
        self.assertIsNotNone(task_subtasks)

    def test_share_permission(self):
        task = {
            'title': '__11test__ title',
            'text': '__test__ text',
            'status': 1
        }
        created_task = self.controller.create_task(task['title'], task['text'],
                                                   task['status'])
        self.controller.share_permission(task_id=created_task.id,
                                         new_user_id=1)
        self.assertEqual([1], created_task.users)

    def test_get_by_tag(self):
        task = {
            'title': '__11test__ title',
            'text': '__test__ text',
            'status': 1,
            'tag': 'life'
        }
        created_task = self.controller.create_task(task['title'],
                                                   task['text'],
                                                   task['status'],
                                                   tags=task['tag'])
        tasks = self.controller.get_tasks_by_tag("life")
        self.assertIsNotNone(task)

    def test_task_parameters_type(self):
        task = {
            'title': '__11test__ title',
            'text': '__test__ text',
            'status': 1,
            'tag': 'life'
        }
        created_task = self.controller.create_task(task['title'],
                                                   task['text'],
                                                   task['status'],
                                                   tags=task['tag'])
        self.assertIsInstance(created_task.title, str)
        self.assertIsInstance(created_task.text, str)
        self.assertIsInstance(created_task.status, int)
        self.assertIsInstance(created_task.tags, str)
        self.controller.delete_task(created_task.id)

    def test_task_type(self):
        tasks = self.controller.get_tasks()
        self.assertIsInstance(tasks, list)

    def test_cron_string_periodic_task(self):
        with self.assertRaises(errs.CronValueError):
            self.controller.create_periodic_task(title="title",
                                                 text="text,",
                                                 status=1,
                                                 start_date="01/02/12 00:00",
                                                 deadline="02/02/12 00:00",
                                                 period="* * help",
                                                 parent_id=666)

    def test_parent_id_periodic_task(self):
        with self.assertRaises(errs.TaskWithParentIdNotExistError):
            self.controller.create_periodic_task(title="title",
                                                 text="text,",
                                                 status=1,
                                                 start_date="01/02/12 00:00",
                                                 deadline="02/02/12 00:00",
                                                 period="* * * * *",
                                                 parent_id=666)

    def test_delete_task(self):
        with self.assertRaises(errs.TaskNotExistError):
            self.controller.delete_task(task_id=89)

    def test_share_permission_exception(self):
        with self.assertRaises(errs.TaskNotExistError):
            self.controller.share_permission(new_user_id=1, task_id=666)
Example #12
0
class TaskView:
    def __init__(self):
        self.user_controller = UserController()
        self.controller = TaskController(
            self.user_controller.user_id(get_token()))

    def create_new_task(self, args):
        try:
            self.controller.create_task(args.title, args.text, args.status,
                                        args.tags, args.parent_id, args.date)
        except (errs.TaskNotExistError,
                errs.TaskWithParentIdNotExistError) as e:
            errs_help.console_print(e)
        except ValueError:
            print("Not valid date")

    def create_new_periodic_task(self, args):
        try:
            self.controller.create_periodic_task(args.title, args.text,
                                                 args.status, args.start_date,
                                                 args.date, args.period,
                                                 args.tags, args.parent_id)
        except (errs.TaskWithParentIdNotExistError, errs.TaskNotExistError,
                errs.CronValueError) as e:
            errs_help.console_print(e)
        # except ValueError:
        #     print("Not valid date")

    def delete_task(self, args):
        try:
            self.controller.delete_task(args.task_id)
        except (errs.AccessError, errs.TitleError, errs.TaskNotExistError,
                errs.UserNotHaveAccessToTaskError) as e:
            errs_help.console_print(e)

    def get_tasks(self, args):
        tasks = self.controller.get_tasks()
        for task in tasks:
            task_helper.print_task(task)
            self.__print_subtasks(task['subtasks'], 2)

    def get_task_by_id(self, args):
        try:
            task = self.controller.get_task_by_id(args.task_id)
            task_helper.print_task(task)
        except (errs.TaskNotExistError, errs.AccessError) as e:
            errs_help.console_print(e)

    def edit_task(self, args):
        try:
            self.controller.edit_task(args.task_id,
                                      {args.parameter: args.new_parameter})
        except (errs.AccessError, errs.CronValueError, errs.TaskNotExistError,
                errs.StatusValueError, errs.IncorrectDateValueError) as e:
            errs_help.console_print(e)

    def get_tasks_by_tag(self, args):
        try:
            tasks = self.controller.get_tasks_by_tag(args.tag)

            for task in tasks:
                # print(str(task.id) + "--id--" + " " + task.title +" " + task.text + " " + str(task.status))
                task_helper.print_task(task)
        except (errs.TaskNotExistError, errs.TitleError) as e:
            errs_help.console_print(e)

    def __print_subtasks(self, subtasks, offset=0):
        for subtask in subtasks:
            task_helper.print_task(subtask, offset)
            self.__print_subtasks(subtask['subtasks'], offset + 2)

    def get_task_subtasks(self, args):
        try:
            subtasks = self.controller.get_task_subtasks(args.task_id)
            self.__print_subtasks(subtasks)

        except (errs.TaskNotExistError, errs.AccessError,
                errs.NoSubtaskError) as e:
            errs_help.console_print(e)

    def share_task_permission(self, args):
        try:
            self.controller.share_permission(args.new_user_id, args.task_id)
        except (errs.TaskNotExistError, errs.TitleError,
                errs.AccessError) as e:
            errs_help.console_print(e)

    def get_tasks_on_period(self, args):

        dates_tasks = self.controller.get_tasks_on_period(args.start, args.end)

        for date_tasks in dates_tasks:
            date = list(date_tasks.keys())[0]
            print(date)
            for task in date_tasks[date]:
                task_helper.print_task(task)
Example #13
0
 def __init__(self):
     self.user_controller = UserController()
     self.controller = TaskController(
         self.user_controller.user_id(get_token()))
Example #14
0
def delete_permission(request, task_id):
    current_user = request.user
    controller = TaskController(current_user.id)
    controller.delete_permission(task_id, int(request.POST.get('user_id')))
    return JsonResponse({'success': True, 'url': request.POST.get('redirect')})
Example #15
0
def delete(request, task_id):
    current_user = request.user

    controller = TaskController(current_user.id)
    controller.delete_task(task_id=task_id)
    return HttpResponseRedirect(redirect_to='/tasks')
Example #16
0
 def setUp(self):
     self.controller = CommentController(user_id=1)
     self.task_controller = TaskController(user_id=1)