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