Python Task.course方法代码示例

# 需要导入模块: from tasks.models import Task [as 别名]
# 或者: from tasks.models.Task import course [as 别名]
    def test_task_create_filled(self):
        year = Year.objects.create(start_year=2016)
        group = [Group.objects.create(name='name_groups', year=year)]
        course = Course.objects.create(name='course_name',
                                       year=year)
        course.groups = group
        course.save()

        parent_task = Task.objects.create(title='parent_task',
                                          course=course)

        deadline_time = datetime.now() + timedelta(days=5)

        task = Task()
        task.title = 'title'
        task.course = course
        task.weight = 1
        task.is_hidden = True
        task.parent_task = parent_task
        task.task_text = 'task_text'
        task.score_max = 10
        task.contest_integrated = True
        task.rb_integrated = True
        task.type = Task.TYPE_SIMPLE
        task.deadline_time = deadline_time
        task.contest_id = 1234
        task.problem_id = 'A'
        task.sended_notify = False
        task.one_file_upload = True
        task.save()
        task.groups = group
        task_id = task.id

        task = Task.objects.get(id=task_id)

        self.assertIsInstance(task, Task)
        self.assertEqual(task.title, 'title')
        self.assertEqual(task.course, course)
        self.assertItemsEqual(task.groups.all(), group)
        self.assertEqual(task.weight, 1)
        self.assertEqual(task.is_hidden, True)
        self.assertEqual(task.parent_task, parent_task)
        self.assertEqual(task.task_text, 'task_text')
        self.assertEqual(task.contest_integrated, True)
        self.assertEqual(task.rb_integrated, True)
        self.assertEqual(task.type, Task.TYPE_SIMPLE)
        self.assertEqual(task.deadline_time.replace(tzinfo=None), deadline_time - timedelta(hours=3))
        self.assertEqual(task.contest_id, 1234)
        self.assertEqual(task.problem_id, 'A')
        self.assertEqual(task.sended_notify, False)
        self.assertEqual(task.one_file_upload, True)

# 需要导入模块: from tasks.models import Task [as 别名]
# 或者: from tasks.models.Task import course [as 别名]
    def handle(self, **options):
        course_id = options['course_id']
        if course_id:
            course_id = int(course_id)

        if not course_id:
            raise Exception("--course_id is required!")

        course_src = Course.objects.get(id=course_id)
        course_dst = Course()

        course_dst.__dict__ = copy.deepcopy(course_src.__dict__)
        course_dst.id = None
        course_dst.name += " copy"
        course_dst.save()

        for task_src in Task.objects.filter(course=course_src):
            if task_src.has_parent():
                continue

            print "Copy task {0}".format(task_src.title.encode("utf-8"))
            task_dst = Task()
            task_dst.__dict__ = copy.deepcopy(task_src.__dict__)
            task_dst.id = None
            task_dst.course = course_dst
            task_dst.save()

            for subtask_src in task_src.get_subtasks():
                print ">Copy subtask {0}".format(subtask_src.title.encode("utf-8"))
                subtask_dst = Task()

                subtask_dst.__dict__ = copy.deepcopy(subtask_src.__dict__)
                subtask_dst.id = None
                subtask_dst.parent_task = task_dst
                subtask_dst.course = course_dst
                subtask_dst.save()

# 需要导入模块: from tasks.models import Task [as 别名]
# 或者: from tasks.models.Task import course [as 别名]
def contest_task_import(request):
    if not request.method == 'POST':
        return HttpResponseForbidden()

    course_id = int(request.POST['course_id'])
    course = get_object_or_404(Course, id=course_id)

    contest_id = int(request.POST['contest_id_for_task'])

    tasks = []
    common_params = get_task_params(request, course.issue_status_system.has_accepted_after_deadline())

    got_info, contest_info = get_contest_info(contest_id)

    problem_req = requests.get(PROBLEMS_API.format(lang='ru', cont_id=str(contest_id)),
                               headers=HEADERS)
    problems = []
    if 'result' in problem_req.json():
        problems = problem_req.json()['result']['problems']

    problems_with_score = {problem['id']: problem.get('score') for problem in problems}

    if got_info:
        if problems:
            sort_order = [problem['id'] for problem in problems]
            contest_info['problems'].sort(key=lambda x: sort_order.index(x['problemId']))
        contest_problems = dict(request.POST)['contest_problems[]']
        for problem in contest_info['problems']:
            if problem['problemId'] in contest_problems:
                current_params = common_params['attrs'].copy()
                current_params.update({
                    'title': problem['problemTitle'],
                    'task_text': problem['statement'],
                    'short_title': current_params['short_title'] or problem['alias'],
                    'contest_integrated': True,
                    'contest_id': contest_id,
                    'problem_id': problem['alias']
                })

                if not current_params['score_max'] and problems_with_score:
                    current_params['score_max'] = problems_with_score[problem['problemId']] or 0

                if not current_params['deadline_time'] and 'endTime' in contest_info:
                    current_params['deadline_time'] = make_aware(
                        datetime.datetime.strptime(contest_info['endTime'][:-12], '%Y-%m-%dT%H:%M'),
                        timezone(settings.CONTEST_TIME_ZONE)
                    )

                tasks.append(current_params)

    elif "You're not allowed to view this contest." in contest_info:
        return HttpResponse(json.dumps({'is_error': True,
                                        'error': _(u"net_prav_na_kontest")}),
                            content_type="application/json")
    else:
        return HttpResponseForbidden()

    if not course.user_can_edit_course(request.user):
        return HttpResponseForbidden()

    for task in tasks:
        real_task = Task()
        real_task.course = course
        for attr_name, attr_value in task.items():
            setattr(real_task, attr_name, attr_value)
        real_task.save()

        task_groups = common_params['groups']
        real_task.groups = task_groups
        real_task.set_position_in_new_group(task_groups)

        reversion.set_user(request.user)
        reversion.set_comment("Import task")

    return HttpResponse("OK")

# 需要导入模块: from tasks.models import Task [as 别名]
# 或者: from tasks.models.Task import course [as 别名]
def task_create_or_edit(request, course, task_id=None):
    params = get_task_params(request, course.issue_status_system.has_accepted_after_deadline())
    lang = request.user.get_profile().language

    changed_score_after_deadline = False
    if task_id:
        task = get_object_or_404(Task, id=task_id)
        task_text = task.is_text_json()
        if task_text:
            task_title = json.loads(task.title, strict=False)
            task_title[lang] = params['attrs']['title']
            task_text[lang] = params['attrs']['task_text']
            params['attrs']['title'] = json.dumps(task_title, ensure_ascii=False)
            params['attrs']['task_text'] = json.dumps(task_text, ensure_ascii=False)
        changed_score_after_deadline = task.score_after_deadline != params['attrs']['score_after_deadline']
        params['attrs']['nb_assignment_name'] = task.nb_assignment_name
    else:
        task = Task()
        task.course = course

    for attr_name, attr_value in params['attrs'].items():
        setattr(task, attr_name, attr_value)

    if task.parent_task:
        if task.parent_task.is_hidden:
            task.is_hidden = True
    task.save()

    for subtask in Task.objects.filter(parent_task=task):
        subtask.is_hidden = task.is_hidden
        subtask.save()

    children = params['children']
    for course_task in Task.objects.filter(course=course):
        if children and course_task.id in map(int, children):
            course_task.parent_task = task
            course_task.save()
        elif course_task.parent_task == task:
            course_task.parent_task = None
            course_task.save()

    task_groups = params['groups']
    task.groups = task_groups
    task.set_position_in_new_group(task_groups)

    if task_id and changed_score_after_deadline and task.parent_task:
        student_ids = User.objects.filter(group__in=task_groups).values_list('id', flat=True)
        for student_id in student_ids:
            parent_issue, created = Issue.objects.get_or_create(task_id=task.parent_task.id, student_id=student_id)
            total_mark = Issue.objects \
                .filter(task=task, student_id=student_id) \
                .exclude(task__is_hiddne=True) \
                .exclude(
                    task__score_after_deadline=False,
                    status_field__tag=IssueStatus.STATUS_ACCEPTED_AFTER_DEADLINE) \
                .aggregate(Sum('mark'))['mark__sum'] or 0
            if task.score_after_deadline:
                parent_issue.mark += total_mark
            else:
                parent_issue.mark -= total_mark
            parent_issue.set_status_seminar()

    if task.type == task.TYPE_SEMINAR:
        student_ids = User.objects.filter(group__in=task_groups).values_list('id', flat=True)
        for student_id in student_ids:
            issue, created = Issue.objects.get_or_create(task_id=task.id, student_id=student_id)
            issue.mark = Issue.objects \
                .filter(task__parent_task=task, student_id=student_id) \
                .exclude(task__is_hidden=True) \
                .exclude(
                    task__score_after_deadline=False,
                    status_field__tag=IssueStatus.STATUS_ACCEPTED_AFTER_DEADLINE) \
                .aggregate(Sum('mark'))['mark__sum'] or 0
            issue.set_status_seminar()

    task.save()
    reversion.set_user(request.user)
    if task_id:
        reversion.set_comment("Edit task")
    else:
        reversion.set_comment("Create task")

    return HttpResponse(json.dumps({'page_title': task.get_title(lang) + ' | ' + course.name + ' | ' + str(course.year),
                                    'redirect_page': '/task/edit/' + str(task.id) if not task_id else None}),
                        content_type="application/json")

# 需要导入模块: from tasks.models import Task [as 别名]
# 或者: from tasks.models.Task import course [as 别名]
def add_task(request):
    user = request.user

    if not request.method == 'POST':
        return HttpResponseForbidden()

    hidden_task = False
    if 'hidden_task' in request.POST:
        hidden_task = True

    try:
        course_id = int(request.POST['course_id'])
        task_title = request.POST['task_title'].strip()
        task_text = request.POST['task_text'].strip()
        max_score = int(request.POST['max_score'])
        course = get_object_or_404(Course, id = course_id)
        if course.contest_integrated:
            contest_id = int(request.POST['contest_id'])
            problem_id = request.POST['problem_id'].strip()

        task_group_id = request.POST['task_group_id']
        group_id = request.POST['group_id']
        if task_group_id == "":
            group_id = None
        else:
            group_id = int(task_group_id)

        parent_id = request.POST['parent_id']
        if not parent_id or parent_id == 'null':
            parent_id = None
        else:
            parent_id = int(parent_id)

    except ValueError: #not int
        return HttpResponseForbidden()

    group = None
    if group_id is not None:
        group = get_object_or_404(Group, id = group_id)
    parent = None
    if parent_id is not None:
        parent = get_object_or_404(Task, id = parent_id)

    if not course.user_can_edit_course(user):
        return HttpResponseForbidden()

    max_weight_query = Task.objects.filter(course=course)
    if group:
        max_weight_query = max_weight_query.filter(group=group)
    if parent:
        max_weight_query = max_weight_query.filter(parent_task=parent)

    tasks = max_weight_query.aggregate(Max('weight'))
    _, max_weight = tasks.items()[0]
    if max_weight is None:
        max_weight = 0
    max_weight += 1

    task = Task()
    task.course = course
    task.group = group
    task.parent_task = parent
    task.weight = max_weight
    task.title = task_title
    task.task_text = task_text
    task.score_max = max_score
    if course.contest_integrated:
        task.contest_id = contest_id
        task.problem_id = problem_id
    task.is_hidden = hidden_task
    task.updated_by = user
    task.save()

    return HttpResponse("OK")