def create(request):
if request.method == 'POST':
form = NewTaskForm(request.POST)
if form.is_valid():
data = form.cleaned_data
if len(data['title']) > 500:
return returnErrors(request, 'Task title too long')
elif len(data['description']) > 5000:
return returnErrors(request, 'Task description too long')
else:
# makes a task with the submitted information and the current user
task = Task(owner=request.user, title=data['title'], description=data['description'])
task.save()
# adds collaborators 1, 2 and 3 by finding the user associated with the submitted email
for x in range(1, 4):
if User.objects.filter(username=data['collaborator' + str(x)]).exists():
task.collaborators.add(User.objects.get(username=data['collaborator' + str(x)]))
else:
return returnErrors(request, 'Fill out all task information')
return HttpResponseRedirect('/')
def save_or_update_task(task_form, workspace_id):
project = Project.objects.filter(id=task_form.projectId)[0]
account = Account.objects.filter(username=task_form.assignedPerson)[0]
if (not project):
project = Project.objects.filter(title='Default')[0]
if (task_form.taskId):
# update it
task = Task.objects.filter(id=task_form.taskId)[0]
task.title = task_form.titleName
task.description = task_form.description
task.estimated_hours = task_form.estimatedHours
task.assigned_user = account
task.status = task_form.status
task.project = project
task.save()
else:
# create it
workspace = Workspace.objects.filter(id=workspace_id)[0]
task = Task(title=task_form.titleName,
description=task_form.description,
estimated_hours=task_form.estimatedHours,
status=task_form.status,
project=project,
assigned_user=account,
workspace=workspace)
task.save()
if (task_form.include_to_current_cycle == 'on'):
cycle = get_active_cycle(workspace_id)
cycle.tasks.add(task)
def mutate(self, info, name, description):
task = Task(name=name, description=description, completed=False)
task.save()
ok = True
return CreateTask(task, ok=ok)
def test_missing_contacts(self):
person = models.Person(
legal_name = "Test Person",
slug = 'test-person'
)
person.save()
self.assertItemsEqual(
[ i.category.slug for i in Task.objects_for(person) ],
['find-missing-phone', 'find-missing-email', 'find-missing-address'],
)
# add a phone number and check that the tasks get updated
phone = models.ContactKind(
slug='phone', name='Phone',
)
phone.save()
contact = models.Contact(
content_type = ContentType.objects.get_for_model(person),
object_id = person.id,
kind = phone,
value = '07891 234 567',
)
contact.save()
self.assertItemsEqual(
[ i.category.slug for i in Task.objects_for(person) ],
['find-missing-email', 'find-missing-address'],
)
def test_complete_defaults_to_false(self):
"""
If done not properly specified, then False is returned.
"""
task = Task(title='Test title')
task.save()
self.assertFalse(task.complete)
def tasks(app):
tasks = [
Task(
id='93c15d1a-7ef7-4230-9937-2d083710b9a5',
title='Buy groceries',
is_completed=True,
created_at=datetime.datetime(2017, 7, 4, 10, 55, 0),
),
Task(
id='6616a883-4ae1-408e-8eee-59699236191e',
title='Plan trip to Lisbon',
is_completed=False,
created_at=datetime.datetime(2017, 5, 13, 20, 18, 0),
),
Task(
id='47446e2f-25d5-4672-bdd4-8313fdf8c033',
title='Finish thesis',
is_completed=False,
created_at=datetime.datetime(2017, 1, 18, 9, 30, 0),
),
Task(
id='51a69ff0-2e25-4b69-8073-07a4d59076ef',
title='Watch Alien: Covenant',
is_completed=False,
created_at=datetime.datetime(2017, 5, 17, 21, 32, 0),
),
]
db.session.add_all(tasks)
db.session.commit()
return tasks
def upload(name):
global BASE_DIR
lang_info = json.load(open(BASE_DIR + "info/lang.json", 'r'))
task_folder = BASE_DIR + "test/" + name + "/"
folder = os.listdir(task_folder)
dummy_pattern = re.compile("{}.dummy.in.[0-9a-b]+".format(name))
test_pattern = re.compile("{}.in.[0-9a-b]+".format(name))
dummy = []
test = []
limits = json.load(open(task_folder + "{}.json".format(name), 'r'))
for i in folder:
if dummy_pattern.match(i):
dummy.append(i)
if test_pattern.match(i):
test.append(i)
task = Task(name=name, link='',
time_limit=limits['limits']['time'],
memory_limit=limits['limits']['memory'],
url=name, checker='test/'+name+'/checker',
checker_lang=limits['checker_lang'], tip=0)
task.save()
print type(task.checker)
print(compiler.compilecode(
str(task.checker) + '.' + lang_info[task.checker_lang]['ext'],
str(task.checker), task.checker_lang, lang_info[task.checker_lang]['ext'])
)
p = re.compile('{}.dummy.in.([0-9a-z]+)'.format(name))
insert_test_case(dummy, task, task_folder, False, p)
p = re.compile('{}.in.([0-9a-z]+)'.format(name))
insert_test_case(test, task, task_folder, True, p)
def task_create_page(request, course_id):
course = get_object_or_404(Course, id=course_id)
if not course.user_is_teacher(request.user):
return HttpResponseForbidden()
if request.method == 'POST':
return task_create_or_edit(request, course)
schools = course.school_set.all()
seminar_tasks = Task.objects.filter(type=Task().TYPE_SEMINAR).filter(course=course)
not_seminar_tasks = Task.objects.filter(~Q(type=Task().TYPE_SEMINAR)).filter(course=course)
has_seminar = course.issue_status_system.statuses.filter(tag=IssueStatus.STATUS_SEMINAR).count()
task_types = Task.TASK_TYPE_CHOICES
if not has_seminar:
task_types = filter(lambda x: not x[0] == Task.TYPE_SEMINAR, task_types)
context = {
'is_create': True,
'course': course,
'task_types': task_types,
'seminar_tasks': seminar_tasks,
'not_seminar_tasks': not_seminar_tasks,
'contest_integrated': course.contest_integrated,
'rb_integrated': course.rb_integrated,
'hide_contest_settings': True if not course.contest_integrated else False,
'school': schools[0] if schools else '',
'user_location': request.user.profile.location,
'geo_suggest_url': settings.GEO_SUGGEST_URL
}
return render_to_response('task_create.html', context, context_instance=RequestContext(request))
def task_list(request):
if request.method == 'GET':
tasks = Task.objects.all()
tasks_serializer = TaskSerializer(tasks, many=True)
return JsonResponse(tasks_serializer.data, safe=False)
elif request.method == 'POST':
try:
task_data = JSONParser().parse(request)
task_name = task_data.get('task_name', "default task name")
task_description = task_data.get('task_description', "default task description")
task_start_date = task_data.get('task_start_date', datetime.datetime.now())
if task_start_date == '':
task_start_date = datetime.datetime.now()
task_end_date = task_data.get('task_end_date', datetime.datetime.now())
if task_end_date == '':
task_end_date = datetime.datetime.now()
related_project_name = task_data.get('task_project_name', "default task description")
project = Project.objects.get(name=related_project_name)
task = Task(name=task_name, description=task_description, start_date=task_start_date,
end_date=task_end_date, project=project)
task.save()
return HttpResponse(status=status.HTTP_201_CREATED)
except:
return HttpResponse(status=status.HTTP_400_BAD_REQUEST)
elif request.method == 'DELETE':
Task.objects.all().delete()
return HttpResponse(status=status.HTTP_204_NO_CONTENT)
def test_tasks(self):
s = Supplier()
s.name = 'Joe'
s.save()
p = Property()
p.save()
l = Location(property = p)
l.save()
a = Asset(location = l)
a.save()
t = Task(asset = a)
t.name = 'Mop floors'
t.frequency = 1
t.save()
q = Quote(supplier = s)
q.amount = 4
q.save()
self.assertEqual(0, len(q.tasks.all()))
q.tasks.add(t)
self.assertEqual(1, len(q.tasks.all()))
self.assertEqual
self.assertEqual("$4.00 to Mop floors (Joe)", str(q))
def create_task(request):
created_by = request.user
assignable_users = User.objects.filter(is_active=True).order_by(User.USERNAME_FIELD)
if request.method == 'POST':
title = request.POST.get('task')
submitter_mail = request.POST.get('submitter_mail')
status = request.POST.get('status')
priority = request.POST.get('priority')
project_agreement = request.POST.get('project_agreement')
table = request.POST.get('table')
due_date = datetime.strptime(request.POST.get('due_date'), "%Y-%m-%d")
created_date = datetime.strptime(request.POST.get('created_date'),"%Y-%m-%d")
created_by = request.POST.get('created_by')
assigned_to = request.POST.get('assigned_to')
note = request.POST.get('note')
task = Task(task=title, submitter_email=submitter_mail, status=status, priority=priority,
due_date=due_date, created_date=created_date,created_by_id=created_by, assigned_to_id=assigned_to,
project_agreement=project_agreement, table=table, note=note)
task.save()
form = form_data(request)
tasks = Task.objects.all()
return render_to_response('tasks/task_index.html',
RequestContext(request, {
'tasks':Task.objects.all().order_by('created_date').reverse,
'assignable_users': assignable_users,
'created_by': created_by,
'form': form
}))
def addTask(request):
if request.method == "POST":
task = Task(title=request.POST["title"],
description=request.POST["description"])
task.save()
return redirect('viewAllTasks')
return render(request, 'addTask.html')
def test_missing_contacts(self):
person = models.Person(legal_name="Test Person", slug='test-person')
person.save()
self.assertItemsEqual(
[i.category.slug for i in Task.objects_for(person)],
[
'find-missing-phone', 'find-missing-email',
'find-missing-address'
],
)
# add a phone number and check that the tasks get updated
phone = models.ContactKind(
slug='phone',
name='Phone',
)
phone.save()
contact = models.Contact(
content_type=ContentType.objects.get_for_model(person),
object_id=person.id,
kind=phone,
value='07891 234 567',
)
contact.save()
self.assertItemsEqual(
[i.category.slug for i in Task.objects_for(person)],
['find-missing-email', 'find-missing-address'],
)
def test_saving_and_retrieving_items(self):
task = Task()
task.save()
first_match = Match()
first_match.full_text = 'The first match'
first_match.task = task
first_match.save()
second_match = Match()
second_match.full_text = 'The second match'
second_match.task = task
second_match.save()
saved_task = Task.objects.first()
self.assertEqual(saved_task, task)
saved_matches = Match.objects.all()
self.assertEqual(saved_matches.count(), 2)
first_saved_match = saved_matches[0]
second_saved_match = saved_matches[1]
self.assertEqual(first_saved_match.full_text, 'The first match')
self.assertEqual(first_saved_match.task, task)
self.assertEqual(second_saved_match.full_text, 'The second match')
self.assertEqual(second_saved_match.task, task)
def addTask(request):
if request.method == 'POST':
form = AddTask(request.POST)
if form.is_valid():
name = request.POST.get('name', '')
description = request.POST.get('description', '')
date = request.POST.get('date', '')
completed = request.POST.get('completed', False)
task = Task(name=name,
description=description,
date=date,
completed=completed)
task.save()
return render(
request, 'app/thanks.html', {
'title': 'Thanks',
'year': datetime.now().year,
'message': 'task added',
})
else:
form = AddTask()
return render(
request, 'app/addtask.html', {
'form': form,
'title': 'AddTask',
'year': datetime.now().year,
'massage': 'addtask',
})
def test_task_next_date_weekly_from_completion(self):
task = Task()
task.name = "Test Task"
task.repeat = Task.WEEKLY
task.repeat_from = Task.COMPLETION_DATE
self.assertEqual(task.next_start_date, None)
self.assertEqual(task.next_due_date, None)
def create_analysis_tasks(analysis_id):
print('analysis_id', analysis_id)
# samples = []
# print('hello!')
#create analysis tasks
# analysis = Analysis.objects.()
analysis = Analysis.objects.get(pk=analysis_id)
print(dir(analysis))
params = analysis.params
files = params['files']
for file in files:
task = Task(user=analysis.user)
task.manifest = {}
task.manifest['files'] = [file]
task.manifest['analysis_types'] = params['analysis_types']
task.status = 'new'
task.analysis = analysis
task.action = 'analysis'
task.save()
analysis.tasks.add(task)
# if 'sample_groups' in params:
# samples = Sample.objects.filter(samplegroup_members__in=params['sample_groups'])
# # sample = Sample.objects.first()
# # print(dir(sample))
# for sample in samples:
# print(sample)
# for file in sample.files.all():
# bam_size = 9223372036854775807
# if file.extension == 'bam':
# if file.size < bam_size:
# bamfile = file
# bam_size = file.size
# print('small bam', bamfile.size)
# get smallest bam file
def assign_tasks(review_milestone, reviewer, routing_algorithm='random', tasks_to_assign=None, simulate=False, chunk_id_task_map={}):
# if tasks_to_assign == None, set tasks_to_assign equal to number required by the milestone for the reviewer's role
if tasks_to_assign == None:
tasks_to_assign = get_num_tasks_for_user(review_milestone, reviewer, simulate=simulate)
reviewer_role = None
if simulate:
reviewer_role = reviewer['membership__role']
else:
reviewer_role = reviewer.membership.get(semester=review_milestone.assignment.semester).role
# get all the chunks that the reviewer can review in the order they should be assigned
reviewable_chunks = get_reviewable_chunks(review_milestone, reviewer, reviewer_role, simulate=simulate, chunk_id_task_map=chunk_id_task_map)
chunks_to_assign = apply_routing_algorithm(reviewable_chunks, tasks_to_assign, routing_algorithm=routing_algorithm)
# if len(chunks_to_assign) < num_tasks_for_user, the reviewer will be assigned fewer
# tasks than they should be and they will be assigned more tasks the next time they
# log in if there are more tasks they can be assigned
# create and save tasks if it's NOT a simulation
if not simulate:
# create tasks for the chunks in chunks_to_assign and save them
for chunk in chunks_to_assign:
# create a ChunkReview if one doesn't already exist
chunk_review, created = ChunkReview.objects.get_or_create(chunk=chunk)
# update the ChunkReview
if reviewer_role == Member.STUDENT or reviewer_role == Member.VOLUNTEER:
chunk_review.student_or_alum_reviewers += 1
elif reviewer_role == Member.TEACHER:
chunk_review.staff_reviewers += 1
chunk_review.save()
# create a task
task = Task(reviewer=reviewer, chunk=chunk, milestone=review_milestone, submission=chunk.file.submission, chunk_review=chunk_review)
task.save()
return len(chunks_to_assign)
def test_task_title_equal_expected_title(self):
"""
If title not equal expected title, then False is returned.
"""
task = Task(title='Test title')
task.save()
self.assertEqual(task.title, 'Test title')
def test_mark_incomplete_marks_incomplete(self):
target = Task()
target.complete_time = timezone.now() - timezone.timedelta(days=1)
self.assertTrue(target.is_complete)
target.mark_incomplete(commit=False)
self.assertFalse(target.is_complete)
def add_project_task(request, slug):
if request.user.is_authenticated():
project = Project.objects.get(slug=slug)
if request.POST:
form = TaskForm(request.POST)
if form.is_valid():
data = form.cleaned_data
td = data['end_date'] - data['start_date']
if td.total_seconds() > 0:
task = Task()
task.name = data['name']
task.description = data['description']
task.start_date = data['start_date']
task.end_date = data['end_date']
task.user = data['user']
task.project = project
task.save()
else:
messages.add_message(request, messages.ERROR,
" end date is less than start date!")
return (redirect(reverse('Task:add_task')))
return (redirect(reverse('Home:manager')))
else:
messages.add_message(request, messages.ERROR, "invalid form")
return (redirect(reverse('Task:add_task')))
else:
form = TaskForm()
send_dict = {}
context_instance = RequestContext(request)
send_dict['project'] = project
send_dict['form'] = form
return render_to_response('tasks/add_task.html', send_dict,
context_instance)
else:
return redirect(reverse('Login:login'))
def test_timestamp_field(self):
T = Task(claimedTime=123456789,
owner_id=2,
hub_id=2,
description="asd")
T.save()
self.assertEqual(T.as_dict()['claimedTime'], 123456789)
def test_task_repeat_daily_no_start_no_due_completion(self):
task = Task()
task.name = "Test Task"
task.repeat = Task.DAILY
task.repeat_from = Task.COMPLETION_DATE
self.assertEqual(task.next_start_date, None)
self.assertEqual(task.next_due_date, None)
def test_frequency_object(self):
"""
Ensure that the .frequency setter works with Frequency objects, too.
"""
t = Task()
for value in [0, 1, 6, 12]:
t.frequency = Frequency(value)
self.assertEqual(value, t._frequency)
def test_mark_complete_marks_complete(self):
target = Task()
target.complete_time = None
self.assertFalse(target.is_complete)
target.mark_complete(commit=False)
time.sleep(0.001)
self.assertTrue(target.is_complete)
def create_database_task(cls, *args, **kwargs):
task = Task(name=cls.task_name(),
started_at=timezone.now(),
status=Task.STATUS_PENDING,
started_by=kwargs['started_by'],
progress=0)
task.save()
return task
def setUp(self):
self.tasks_url = reverse('tasks')
self.user = User.objects.create(username='******',
email='*****@*****.**',
is_staff=True, is_active=True)
task = Task(title='task-1', description='description-of-task-1',
created_by=self.user)
task.save()
def test_mark_complete_marks_complete(self):
target = Task()
target.complete_time = None
self.assertFalse(target.is_complete)
target.mark_complete()
self.assertTrue(target.is_complete)
def test_can_create_a_task_with_a_title_and_status_complete(self):
"""
If done not properly specified, then False is returned.
"""
task = Task(title='Test title', complete=True)
task.save()
self.assertEqual(task.title, 'Test title') # No need?
self.assertTrue(task.complete)
def post(self, request):
res_dict = {
'status': None,
'message': None,
'data': None
}
req_list_id = request.data.get('list_id')
req_task_name = request.data.get('name')
req_task_desc = request.data.get('description') if request.data.get('description', None) else ''
req_task_urg = request.data.get('urgency')
if req_list_id and TaskList.objects.filter(id=req_list_id).exists() and req_task_name and req_task_name != '' and req_task_urg and req_task_urg != '':
try:
task_list = TaskList.objects.get(id=req_list_id)
user_has_perm = ListAccess.objects.filter(user=request.user, list=task_list)
if user_has_perm.count() != 1 or user_has_perm.first().role != 'owner':
raise PermissionError("You do not have permission to edit this list")
new_task = Task(name=req_task_name, list=task_list, description=req_task_desc, urgency=req_task_urg)
new_task.save()
res_dict['status'] = 'success'
res_dict['message'] = 'Task created!'
res_dict['data'] = {
'name': new_task.name,
'description': new_task.description,
'urgency': new_task.urgency,
'task_completed': new_task.task_completed,
'list_id': new_task.list.id
}
res = Response(res_dict)
res.status_code = 200
except PermissionError as perm_err:
res_dict['status'] = 'failed'
res_dict['message'] = 'Permission denied! Error: ' + perm_err.__str__()
res_dict['data'] = None
res = Response(res_dict)
res.status_code = 403
except Exception as e:
res_dict['status'] = 'failed'
res_dict['message'] = 'Something went wrong, Error: ' + e.__str__()
res_dict['data'] = None
res = Response(res_dict)
res.status_code = 500
else:
res_dict['status'] = 'failed'
res_dict['message'] = 'Invalid name or list_id passed.'
res_dict['data'] = None
res = Response(res_dict)
res.status_code = 400
return res
def home(request):
if request.method == 'POST':
title = request.POST.get('todo')
todo = Task(title=title)
todo.save()
messages.success(request, ('Item Added to List'))
data = Task.objects.all()
content = {'data': data}
return render(request, 'list.html', content)
def handle(self, *args, **options): Task.objects.all().delete() for i in range(100): task = Task() task.title = 'Task-%d'%i task.text = 'Text %d'%i task.save()
def post(request):
task = request.POST.get('task')
new = Task()
new.name = task
new.status = Status.objects.get(name='New')
new.save()
response = HttpResponse()
response.status_code = 201
return response
def add_task(request):
if request.method == 'POST':
form = TaskForm(request.POST)
if form.is_valid():
new_task = Task(description=request.POST.get('description', ''))
new_task.save()
return HttpResponseRedirect(reverse('task-list'))
form = TaskForm()
return render(request, 'tasks/add.html', {'form': form})
def test_complete_toggle_status_to_false(self):
"""
Test for switch check - complete must be false
"""
task = Task(title="A test title", complete=True)
task.save()
task = get_object_or_404(Task, pk=task.id)
task.complete = False
self.assertEqual(task.complete, False)
def test_mark_incomplete_marks_incomplete(self):
target = Task()
target.complete_time = timezone.now()
self.assertTrue(target)
target.mark_incomplete()
self.assertTrue(target.is_complete)
def setUp(self):
self.tasks_url = reverse('tasks')
self.user = User.objects.create(username='******',
email='*****@*****.**',
is_staff=True,
is_active=True)
task = Task(title='task-1',
description='description-of-task-1',
created_by=self.user)
task.save()
def add_project_task(request,slug):
if request.user.is_authenticated():
project = Project.objects.get(slug = slug)
if request.POST:
form = TaskForm(request.POST)
if form.is_valid():
data = form.cleaned_data
td = data['end_date'] - data['start_date']
if td.total_seconds()>0:
task = Task()
task.name = data['name']
task.description = data['description']
task.start_date = data['start_date']
task.end_date = data['end_date']
task.user = data['user']
task.project = project
task.save()
else:
messages.add_message(request, messages.ERROR,
" end date is less than start date!")
return (redirect(reverse('Task:add_task')))
return (redirect(reverse('Home:manager')))
else:
messages.add_message(request, messages.ERROR,
"invalid form")
return (redirect(reverse('Task:add_task')))
else:
form = TaskForm()
send_dict={}
context_instance=RequestContext(request)
send_dict['project'] = project
send_dict['form'] = form
return render_to_response('tasks/add_task.html',send_dict,context_instance)
else:
return redirect(reverse('Login:login'))
def update(self, pk): try: task = Task.objects.get(pk=pk) except Task.DoesNotExist: task = Task() task.title = self.data['title'] task.description = self.data['description'] task.save() return task
def mutate_and_get_payload(cls, root, info, **input):
id = input.get('id')
task = Task.objects.get(id=id)
if task is None:
task = Task()
for k, v in input.items():
setattr(task, k, v)
task.save()
return cls(task)
def form_valid(self, form):
bundle = TaskBundle()
bundle.save()
for url in form.cleaned_data['urls']:
task = Task(link=url)
task.bundle = bundle
task.save()
return HttpResponseRedirect(reverse('bundle_detail', args=[bundle.pk]))
def add_task(request, group, meeting):
"""
Adds a task to a minutes item.
"""
item_number = request.POST['ajax_button'][9:]
item_number = int(item_number)
predecessors = Task.objects.filter(item_id=item_number)
no_of_precessors = predecessors.count()
new_task_number = no_of_precessors + 1
new_task = Task(item_id=int(item_number), group=group, meeting=meeting,
task_no=new_task_number, status = 'Draft')
new_task.save(group)
def task_set_view(request, pk): # zobrazenie sady ako zoznam
task_set = get_object_or_404(TaskSet, pk=pk)
if not TaskSet.can_see(task_set, request.user):
raise Http404
# vytvori sa alebo updatne aktualna sada
act = Active.objects.get_or_create(user=request.user)
a = act[0]
a.task_set = task_set
a.save()
# zoznam uloh v sade; iba tie, ktorym moze vidiet zadania v zozname
q = Task.objects.filter(task_set=task_set)
q_ids = [o.id for o in q if Task.can_see(o, request.user, "t")]
tasks = q.filter(id__in=q_ids)
# zoznam sad do horneho menu; iba tie, ktore user moze vidiet
q = TaskSet.objects.order_by("title")
q_ids = [o.id for o in q if TaskSet.can_see(o, request.user)]
sets = q.filter(id__in=q_ids)
# roztriedenie uloh na kategorie (ci su vyriesene/precitane)
# v tomto poradi sa mu aj zobrazuju
task_cat = []
task_cat.append({"tasks": [], "type": "act_sub"}) # 0
task_cat.append({"tasks": [], "type": "act_read"}) # 1
task_cat.append({"tasks": [], "type": "sol_sub"}) # 2
task_cat.append({"tasks": [], "type": "sol_read"}) # 3
for task in tasks:
if Task.is_solved(task, request.user):
if task.type == Task.SUBMIT:
task_cat[2]["tasks"].append(task)
elif task.type == Task.READ:
task_cat[3]["tasks"].append(task)
elif Task.is_enabled(task, request.user):
if task.type == Task.SUBMIT:
task_cat[0]["tasks"].append(task)
elif task.type == Task.READ:
task_cat[1]["tasks"].append(task)
return render_to_response(
"tasks/task_set.html",
{
"active_app": "tasks", # kvoli havnemu menu
"task_set": task_set, # aktualna sada
"sets": sets, # viditelne sady v taboch
"style": "list", # styl zobrazovania sady
"categories": task_cat, # ulohy podla kategorii
"tasks": tasks, # danej sady
},
context_instance=RequestContext(request),
)
def import_tasks(request):
""" View in the admin """
if request.method == 'POST':
form = ImportForm(request.POST, request.FILES)
if form.is_valid():
try:
Task.import_Tasks(form.files['file'], request.user)
messages.success(request, "The import was successfull.")
return HttpResponseRedirect(urlresolvers.reverse('admin:tasks_task_changelist'))
except Exception, e:
from django.forms.utils import ErrorList
msg = "An Error occured. The import file was propably malformed.: %s" % str(e)
form._errors["file"] = ErrorList([msg])
def create_task(task_title, user):
"""
Creates the task with the `task_title` and assigns the `user` to
`assigned_users` if `assigned_users` is empty.
"""
task = Task()
task.save_from_re(task_title)
# If user was not yet assigned use the email user.
if len(task.assigned_users.all()) == 0:
task.assigned_users.add(user)
return task
def task_set_view(request, pk): # zobrazenie sady ako zoznam
task_set = get_object_or_404(TaskSet, pk=pk)
if not TaskSet.can_see(task_set, request.user):
raise Http404
# vytvori sa alebo updatne aktualna sada
act = Active.objects.get_or_create(user=request.user)
a = act[0]
a.task_set = task_set
a.save()
# zoznam uloh v sade; iba tie, ktorym moze vidiet zadania v zozname
q = Task.objects.filter(task_set=task_set)
q_ids = [o.id for o in q if Task.can_see(o, request.user, 't')]
tasks = q.filter(id__in=q_ids)
# zoznam sad do horneho menu; iba tie, ktore user moze vidiet
q = TaskSet.objects.order_by('title')
q_ids = [o.id for o in q if TaskSet.can_see(o, request.user)]
sets = q.filter(id__in=q_ids)
# roztriedenie uloh na kategorie (ci su vyriesene/precitane)
# v tomto poradi sa mu aj zobrazuju
task_cat = []
task_cat.append({'tasks': [], 'type': 'act_sub'}) # 0
task_cat.append({'tasks': [], 'type': 'act_read'}) # 1
task_cat.append({'tasks': [], 'type': 'sol_sub'}) # 2
task_cat.append({'tasks': [], 'type': 'sol_read'}) # 3
for task in tasks:
if Task.is_solved(task, request.user):
if task.type == Task.SUBMIT:
task_cat[2]['tasks'].append(task)
elif task.type == Task.READ:
task_cat[3]['tasks'].append(task)
elif Task.is_enabled(task, request.user):
if task.type == Task.SUBMIT:
task_cat[0]['tasks'].append(task)
elif task.type == Task.READ:
task_cat[1]['tasks'].append(task)
return render(request, 'tasks/task_set.html',
{
'active_app': 'tasks', # kvoli havnemu menu
'task_set': task_set, # aktualna sada
'sets': sets, # viditelne sady v taboch
'style': 'list', # styl zobrazovania sady
'categories': task_cat, # ulohy podla kategorii
'tasks': tasks, # danej sady
},
)
def addTask(request):
if request.method == 'POST':
form = AddTask(request.POST)
if form.is_valid():
name = request.POST.get('name', '')
description = request.POST.get('description', '')
date = request.POST.get('date', '')
completed = request.POST.get('completed', False)
task = Task(name=name, description=description, date=date, completed=completed)
task.save()
return render(request, 'app/thanks.html', {'title':'Thanks', 'year':datetime.now().year, 'message': 'task added',})
else:
form = AddTask()
return render(request, 'app/addtask.html', {'form': form, 'title':'AddTask', 'year':datetime.now().year, 'massage': 'addtask',})
def test_frequency(self):
t = Task()
tests = {
0: "once",
1: "every month",
2: "every 2 months",
12: "every year",
13: "every 13 months",
24: "every 2 years"
}
for value, expected in tests.items():
t.frequency = value
self.assertEqual(expected, str(t.frequency))
def task_view(request, pk): # zadanie ulohy
task = get_object_or_404(Task, pk=pk)
if not Task.can_see(task, request.user, 't'):
raise Http404
# vytvorime alebo updatneme aktivnu ulohu
act = Active.objects.get_or_create(user=request.user)
if task.type == task.SUBMIT:
a = act[0]
a.task = task
a.save()
# ak sa submitovalo
error = False
if request.method == 'POST':
form = TaskSubmitForm(request.POST, request.FILES)
if form.is_valid():
submit_id = helpers.process_submit(
request.FILES['submit_file'],
task,
form.cleaned_data['language'],
request.user)
if submit_id[0]:
return HttpResponseRedirect(reverse('submit:protocol', args=(submit_id[1],)) + '#protocol')
else:
error = submit_id[1]
else:
error = 'file-error'
# pridame seen
stalker = Stalker(user=request.user, task=task, seen=datetime.now())
stalker.save()
form = TaskSubmitForm()
submits = Submit.objects.filter(task=pk, user=request.user).order_by('-timestamp')
is_solved = Task.is_solved(task, request.user)
return render(request, 'tasks/task.html',
{
'active_app': 'tasks', # hlavne menu
'active': 'text', # ci si pozerame zadanie alebo vzorak
'is_solved': is_solved, # kvoli linku v taboch
'task': task,
'form': form, # submitovaci formular
'submits': submits, # doterajsie submity v ulohe
'error': error, # chyba suboru / nepodarene pripojenie na testovac
'req_user': request.user, # momentalne lognuty (kvoli odkazu na riesenie pre adminov)
},
)
def task_view(request, pk): # zadanie ulohy
task = get_object_or_404(Task, pk=pk)
if not Task.can_see(task, request.user, "t"):
raise Http404
# vytvorime alebo updatneme aktivnu ulohu
act = Active.objects.get_or_create(user=request.user)
if task.type == task.SUBMIT:
a = act[0]
a.task = task
a.save()
# ak sa submitovalo
error = False
if request.method == "POST":
form = TaskSubmitForm(request.POST, request.FILES)
if form.is_valid():
submit_id = helpers.process_submit(
request.FILES["submit_file"], task, form.cleaned_data["language"], request.user
)
if submit_id[0]:
return HttpResponseRedirect(reverse("submit:protocol", args=(submit_id[1],)) + "#protocol")
else:
error = submit_id[1]
else:
error = "file-error"
# pridame seen
stalker = Stalker(user=request.user, task=task, seen=datetime.now())
stalker.save()
form = TaskSubmitForm()
submits = Submit.objects.filter(task=pk, user=request.user).order_by("-timestamp")
is_solved = Task.is_solved(task, request.user)
return render_to_response(
"tasks/task.html",
{
"active_app": "tasks", # hlavne menu
"active": "text", # ci si pozerame zadanie alebo vzorak
"is_solved": is_solved, # kvoli linku v taboch
"task": task,
"form": form, # submitovaci formular
"submits": submits, # doterajsie submity v ulohe
"error": error, # chyba suboru / nepodarene pripojenie na testovac
"req_user": request.user, # momentalne lognuty (kvoli odkazu na riesenie pre adminov)
},
context_instance=RequestContext(request),
)
def task_set_graph_view(request, pk=False): # zobrazenie sady ako graf
# ak sme nespecifikovali sadu (menu->Ulohy), zobrazi sa/vytvori sa aktivna
if not pk:
act = Active.objects.get_or_create(user=request.user)
pk = act[0].task_set.id
task_set = get_object_or_404(TaskSet, pk=pk)
if not TaskSet.can_see(task_set, request.user):
raise Http404
# vytvori sa alebo updatne aktualna sada
act = Active.objects.get_or_create(user=request.user)
a = act[0]
a.task_set = task_set
a.save()
# zoznam uloh v sade; iba tie, o ktorych moze vediet
q = Task.objects.filter(task_set=task_set)
q_ids = [o.id for o in q if Task.can_see(o, request.user, "g")]
tasks = q.filter(id__in=q_ids)
# zoznam sad do horneho menu; iba tie, ktore user moze vidiet
q = TaskSet.objects.order_by("title")
q_ids = [o.id for o in q if TaskSet.can_see(o, request.user)]
sets = q.filter(id__in=q_ids)
# roztriedime kvoli vykreslovaniu v grafe
solved_tasks = []
actual_tasks = []
invis_tasks = []
for task in tasks:
if Task.is_solved(task, request.user):
solved_tasks.append(task)
elif Task.is_enabled(task, request.user):
actual_tasks.append(task)
else:
invis_tasks.append(task)
return render_to_response(
"tasks/task_set_graph.html",
{
"active_app": "tasks", # hlavne menu
"task_set": task_set, # aktualna sada
"sets": sets, # vsetky sady
"style": "graph", # styl zobrazovania sady
},
context_instance=RequestContext(request),
)
def new_task(request):
if request.method == 'POST':
form = newTask(request.POST)
if form.is_valid():
cd = form.cleaned_data
t = Task(task = cd['task'], due_date = cd['due_date'], complete = False)
t.save()
print "Did this f*****g work???!!!!"
return HttpResponseRedirect('/tasks/')
else:
form = newTask()
return render_to_response('tasks/new_task.html', {
'form' : form },
)
def newTask(request):
if request.method == 'POST':
form = createTaskForm(request.POST)
if form.is_valid():
data = form.cleaned_data
newTask = Task(owner=request.user, title=data['title'], description=data['description'])
newTask.save()
if User.objects.filter(username=data['collaborator1']).exists():
newTask.collaborators.add(User.objects.get(username=data['collaborator1']))
if User.objects.filter(username=data['collaborator2']).exists():
newTask.collaborators.add(User.objects.get(username=data['collaborator2']))
if User.objects.filter(username=data['collaborator3']).exists():
newTask.collaborators.add(User.objects.get(username=data['collaborator3']))
return HttpResponseRedirect('/')
def import_tasks(request):
""" View in the admin """
if request.method == 'POST':
form = ImportForm(request.POST, request.FILES)
if form.is_valid():
try:
Task.import_Tasks(form.files['file'], request.user)
request.user.message_set.create(message="The import was successfull.")
return HttpResponseRedirect(urlresolvers.reverse('admin:tasks_task_changelist'))
except:
from django.forms.util import ErrorList
msg = "An Error occured. The import file was propably malformed."
form._errors["file"] = ErrorList([msg])
else:
form = ImportForm()
return render_to_response('admin/tasks/task/import.html', {'form': form, 'title':"Import Task" }, RequestContext(request))
def get_usertasks(context, user, asvar=None):
val = Task.get_all().filter(assignee=user)
if asvar:
context[asvar] = val
return ""
else:
return val
def get_alltasks(context, asvar=None):
val = Task.get_all()
if asvar:
context[asvar] = val
return ""
else:
return val
def project_task_count(context, project, asvar=None):
val = Task.get_project_count(project)
if asvar:
context[asvar] = val
return ""
else:
return val
def api_task_add():
task = Task.create(g.db, context=g.user.id,
title=request.form['title'],
text=request.form['text'],
user_id=g.user.id)
g.db.add(task)
g.db.commit()
return json.jsonify(status="OK", task=task.as_dict())
def example_solution_view(request, pk): # vzorak
task = get_object_or_404(Task, pk=pk)
if not Task.can_see(task, request.user, 's'):
raise Http404
if task.type == task.READ:
raise Http404
return render(request, 'tasks/example_solution.html',
{
'is_solved': Task.is_solved(task, request.user), # kvoli linku v taboch
'active_app': 'tasks', # hlavne menu
'active': 'ex_sol', # ci sa zobrazuje zadanie alebo vzorak
'task': task,
},
)
