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
})
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})
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)
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)
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)