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 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 create_mock_data(email):
account = Account(username=email, email=email)
account.save()
workspace = Workspace(account=account)
workspace.save()
project1 = Project(title='Project 1',
description='Project1 description',
workspace=workspace,
color='#ffffff')
project1.save()
task1 = Task(title='task 1',
description='task 1 description',
project=project1,
estimated_hours=1,
status='OPEN',
workspace=workspace,
assigned_user=account)
task1.save()
task2 = Task(title='task 2',
description='task 2 description',
project=project1,
estimated_hours=1,
status='READY',
workspace=workspace,
assigned_user=account)
task2.save()
project2 = Project(title='Project 2',
description='Project2 description',
workspace=workspace,
color='#ffff00')
project2.save()
task3 = Task(title='task 3',
description='task 3 description',
project=project2,
estimated_hours=1,
status='IN_PROGRESS',
workspace=workspace,
assigned_user=account)
task3.save()
task4 = Task(title='task 4',
description='task 4 description',
project=project2,
estimated_hours=1,
status='DONE',
workspace=workspace,
assigned_user=account)
task4.save()
tasks = Task.objects.all()
cycle = Cycle(goal_title='Default',
start_date=timezone.now(),
workspace=workspace)
cycle.save()
activeCycle = Cycle(goal_title='Active',
start_date=timezone.now(),
end_date=timezone.now() + timezone.timedelta(7),
workspace=workspace)
activeCycle.save()
activeCycle.tasks.set(tasks)
cycle.save()
def test_service_get_by_name(session):
from tasks.models import Task
from tasks.service import get_by_user
task1 = Task(description="test1", user_id=1)
task2 = Task(description="test2", user_id=2)
session.add(task1)
session.add(task2)
session.commit()
query = get_by_user(session, 2)
count = query.count()
assert count == 1
def test_service_delete(session):
from tasks.models import Task
from tasks.service import delete
task1 = Task(description="test1", user_id=1)
task2 = Task(description="test2", user_id=1)
session.add(task1)
session.add(task2)
session.commit()
delete(session, task1.id)
count = session.query(Task).filter(Task.id == task1.id).count()
assert count == 0
def task_edit_page(request, task_id):
task = get_object_or_404(Task, id=task_id)
if not task.course.user_is_teacher(request.user):
return HttpResponseForbidden()
if request.method == 'POST':
return task_create_or_edit(request, task.course, task_id)
groups_required = []
groups = task.groups.all()
if task.type == task.TYPE_SEMINAR:
children_groups = reduce(lambda x, y: x + y, [list(child.groups.all()) for child in task.children.all()], [])
groups_required = set(children_groups).intersection(groups)
else:
for group in groups:
if Issue.objects.filter(task=task, student__in=group.students.all()).count():
groups_required.append(group)
schools = task.course.school_set.all()
seminar_tasks = Task.objects.filter(type=Task().TYPE_SEMINAR).filter(course=task.course)
not_seminar_tasks = Task.objects.filter(~Q(type=Task().TYPE_SEMINAR)).filter(course=task.course)
task_types = task.TASK_TYPE_CHOICES
if task.type == task.TYPE_SEMINAR:
task_types = filter(lambda x: not x[0] == task.TYPE_FULL, task_types)
else:
task_types = filter(lambda x: not x[0] == task.TYPE_SEMINAR, task_types)
context = {
'is_create': False,
'course': task.course,
'task': task,
'task_types': task_types,
'groups_required': groups_required,
'show_help_msg_task_group': True if groups_required else False,
'seminar_tasks': seminar_tasks,
'not_seminar_tasks': not_seminar_tasks,
'contest_integrated': task.contest_integrated,
'rb_integrated': task.rb_integrated,
'hide_contest_settings': True if not task.contest_integrated or task.type in [task.TYPE_SIMPLE,
task.TYPE_MATERIAL] 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_edit.html', context, context_instance=RequestContext(request))
def course_page(request, course_id):
"""Page with course related information
contexts:
- tasklist
- tasks_description
"""
user = request.user
if not user.get_profile().is_active():
raise PermissionDenied
course = get_object_or_404(Course, id=course_id)
if course.is_python_task:
return pythontask.tasks_list(request, course)
schools = course.school_set.all()
if course.private and not course.user_is_attended(request.user):
return render_to_response('courses/course_forbidden.html',
{"course": course,
'school': schools[0] if schools else '',
'invite_form': InviteActivationForm()},
context_instance=RequestContext(request))
course.can_edit = course.user_can_edit_course(user)
if course.can_edit:
groups = course.groups.all().order_by('name')
tasks = [{'group': tgr.group, 'task': tgr.task} for tgr in
TaskGroupRelations.objects.filter(task__course=course, group__in=groups, deleted=False).order_by(
'group', 'position')]
else:
groups = Group.objects.filter(students=user, course__in=[course])
tasks = TaskGroupRelations.objects.filter(
task__course=course, group__in=groups, deleted=False
).order_by(
'group', 'position'
).values_list(
'task__id', flat=True
).distinct()
tasks = Task.objects.filter(id__in=tasks)
if StudentCourseMark.objects.filter(student=user, course=course):
mark = StudentCourseMark.objects.get(student=user, course=course).mark
else:
mark = None
context = {}
context['course'] = course
context['tasks'] = tasks
context['mark'] = mark or '--'
context['visible_queue'] = course.user_can_see_queue(user),
context['visible_attendance_log'] = course.user_can_see_attendance_log(user),
context['user_is_teacher'] = course.user_is_teacher(user)
context['task_types'] = dict(Task().TASK_TYPE_CHOICES).items()
context['show_hidden_tasks'] = request.session.get(
str(request.user.id) + '_' + str(course.id) + '_show_hidden_tasks', False)
context['school'] = schools[0] if schools else ''
context['visible_attendance_log'] = course.user_can_see_attendance_log(request.user)
context['jupyterhub_url'] = getattr(settings, 'JUPYTERHUB_URL', '')
return render_to_response('courses/course.html', context, context_instance=RequestContext(request))
def post(self, request):
# crear el formulario con los datos del POST
task_with_user = Task(owner=request.user)
form = TaskForm(request.POST, instance=task_with_user)
# validar el formulario
if form.is_valid():
# crear la tarea
task = form.save()
# mostrar mensaje de exito
message = 'Tarea creada con éxito! <a href="{0}">Ver tarea</a>'.format(
reverse('tasks_detail',
args=[task.pk
]) # genera la URL de detalle de esta tarea
)
# limpiamos el formulario creando uno vacío para pasar a la plantilla
form = TaskForm()
else:
# mostrar mensaje de error
message = "Se ha producido un error"
# renderizar la plantilla
context = {"form": form, "message": message}
return render(request, 'tasks/new.html', context)
def bulk_action(request):
if request.method == 'POST':
files = request.POST.getlist('files')
action = request.POST['action']
for file_id in files:
# file = File.objects.get(pk=file_id)
if request.user.is_staff:
file = get_object_or_404(File, pk=file_id)
else:
file = get_object_or_404(File, pk=file_id, user=request.user)
if action == "delete":
file.delete()
if action == "check":
task_manifest = {}
task_manifest['file'] = file.id
task_manifest['action'] = action
task = Task(user=request.user)
task.manifest = task_manifest
task.status = 'new'
task.action = action
task.user = request.user
task.save()
check_file.delay(task.id)
file.status = 'scheduled'
file.save()
return redirect('files-index')
def run_task(request):
if request.method == 'GET':
print(request.GET)
if 'action' in request.GET:
action = request.GET['action']
file_id = request.GET['file_id']
file = File.get_object_or_404(pk=file_id)
if action == "check":
task_manifest = {}
task_manifest['file'] = file.id
task_manifest['action'] = action
task = Task(user=request.user)
task.manifest = task_manifest
task.status = 'new'
task.action = action
task.user = request.user
task.save()
check_file.delay(task.id)
file.status = 'scheduled'
file.save()
return redirect('files-index')
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 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 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 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 task_add_edit(request, polity_id, task_id=None):
polity = get_object_or_404(Polity, id=polity_id)
if not (polity.is_member(request.user)
or polity.is_wrangler(request.user)):
raise PermissionDenied()
if task_id:
task = get_object_or_404(Task, id=task_id, polity=polity)
# We don't want to edit anything that has already done.
if task.is_done:
raise PermissionDenied()
else:
task = Task(polity=polity)
if request.method == 'POST':
form = TaskForm(request.POST, instance=task)
if form.is_valid():
task = form.save()
return redirect(reverse('task_detail', args=(polity_id, task.id)))
else:
form = TaskForm(instance=task)
ctx = {
'polity': polity,
'form': form,
}
return render(request, 'tasks/task_add_edit.html', ctx)
def user_onboarding(user, request):
label_names = ["Work", "Shopping", "Personal"]
descriptions = [
"Plan career related stuff here.",
"From vegetables to that pending car repair.",
"Everything about your life at home."
]
for i in range(0, len(label_names)):
label_obj = Label(user=user,
name=label_names[i],
description=descriptions[i])
print(label_obj)
label_obj.save()
sample_task = Task(user=user, name = "Welcome to Ultimate! [Tutorial]", \
desc = "Use ultimate to plan your work, chores and play - create tasks, attach sub-goals to tasks and set due dates.")
sample_task.save() # you cannot add a label unless the task is saved
sample_task.labels.add(label_obj)
sample_task.save()
subtask_names = [
"Try creating a new task",
"Manage labels by creating a new label or editing an existing one",
"Create subtasks and mark them as complete",
"Delete this task once you're done"
]
for subtask_name in subtask_names:
subtask = SubTask(name=subtask_name, task=sample_task)
print(subtask)
subtask.save()
def post(self, request, *args, **kwargs):
file = request.data.get(u'file', None)
delimiter = str(request.data.get('delimiter', None))
encoding = request.data.get(u'encoding', None)
if request.data.get(u'mapping'):
mapping = json.loads(request.data.get(u'mapping'))
else:
mapping = dict()
headers = csv.reader(file, encoding=encoding,
delimiter=delimiter).next()
reader = csv.DictReader(file,
fieldnames=headers,
encoding=encoding,
delimiter=delimiter)
records = []
for v in self.generate(reader, mapping):
record = Task(label=v[u'label'],
description=v[u'description'],
dev_eta=v[u'dev_eta'])
records.append(record)
if len(records) == 1500:
Task.objects.bulk_create(records)
records = []
if len(records) > 0:
Task.objects.bulk_create(records)
return response.Response(status=status.HTTP_201_CREATED)
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 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 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 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 contest_import_page(request, course_id):
course = get_object_or_404(Course, id=course_id)
if not course.user_is_teacher(request.user):
return HttpResponseForbidden()
schools = course.school_set.all()
seminar_tasks = Task.objects.filter(type=Task().TYPE_SEMINAR).filter(
course=course)
context = {
'is_create': True,
'course': course,
'rb_integrated': course.rb_integrated,
'seminar_tasks': seminar_tasks,
'school': schools[0] if schools else '',
'contest_import': True,
'user_location': request.user.get_profile().location,
'geo_suggest_url': settings.GEO_SUGGEST_URL
}
return render_to_response('contest_import.html',
context,
context_instance=RequestContext(request))
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 add_task(request, flat_id=None):
name = request.data.get('name', None)
user_ids = request.data.get('users', None)
frequency = request.data.get('frequency', None)
if name is None or user_ids is None or frequency is None:
return Response(data={'message': 'Wrong parameters'}, status=400)
if frequency not in ['DAILY', 'WEEKLY', 'MONTHLY']:
return Response(
data={'message': 'Frequency can be: DAILY, WEEKLY, MONTHLY'},
status=400)
try:
flat = Flat.objects.get(id=flat_id)
except ObjectDoesNotExist:
return Response(
data={'message': 'The flat {0} does not exist.'.format(flat_id)},
status=400)
user_list = []
for user_id in user_ids.split(','):
try:
user = User.objects.get(id=user_id)
if user not in flat.users.all():
return Response(data={
'message':
'{0} is not a member of the flat.'.format(user.username)
},
status=400)
user_list.append(user)
except ObjectDoesNotExist:
return Response(data={
'message':
'The user id {0} does not exist.'.format(user_id)
},
status=400)
rule = Rule(frequency=frequency, name='{0}_{1}'.format(frequency, name))
rule.save()
event = Event(rule=rule,
start=datetime.now(),
end=datetime.now() + timedelta(days=60),
calendar=Calendar.objects.get_calendar_for_object(flat))
event.save()
task = Task(flat=flat, name=name, event=event)
task.save()
for u in user_list:
task.users.add(u)
task.refresh_from_db()
return Response(data={
'message': 'Your task has been created.',
'task': TaskSerializer(task).data,
},
status=200)
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 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 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 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 configured_project(business_client, annotator_client):
_project_for_text_choices_onto_A_B_classes = dict(title='Test',
label_config='''
<View>
<Text name="meta_info" value="$meta_info"></Text>
<Text name="text" value="$text"></Text>
<Choices name="text_class" toName="text" choice="single">
<Choice value="class_A"></Choice>
<Choice value="class_B"></Choice>
</Choices>
</View>''')
_2_tasks_with_textA_and_textB = [{
'meta_info': 'meta info A',
'text': 'text A'
}, {
'meta_info': 'meta info B',
'text': 'text B'
}]
# get user to be owner
users = User.objects.filter(
email='*****@*****.**'
) # TODO: @nik: how to get proper email for business here?
project = make_project(_project_for_text_choices_onto_A_B_classes,
users[0])
assert project.ml_backends.first().url == 'http://localhost:8999'
Task.objects.bulk_create([
Task(data=task, project=project)
for task in _2_tasks_with_textA_and_textB
])
return project
def mutate(self, info, name, description):
task = Task(name=name, description=description, completed=False)
task.save()
ok = True
return CreateTask(task, ok=ok)
