def dashboard(request):

	context = RequestContext(request)

	if not request.user.is_authenticated():
		template = get_template('login.html')
		return HttpResponse(template.render(context))

	context["user"] = request.user

	try:
		submission = Submission.objects.get(pk=request.user.id)
	except:
		submission = Submission(user=request.user)
		submission.save()

	if request.user.is_staff:
		template = get_template('staff_dashboard.html')
		return HttpResponse(template.render(context))
	
	else:
		if request.method == 'POST':
			# form = SubmissionForm(request.POST, request.FILES)
			if all((x in request.FILES for x in ['app_form', 'app_info', 'con_form'])):
				newdoc = Version(
					application_form=request.FILES['app_form'],
					applicant_info=request.FILES['app_info'],
					consent_form=request.FILES['con_form'],
					submission=submission)
				newdoc.save()
		versions = Version.objects.filter(submission=submission)
		context["versions"] = versions
		context["submission"] = submission
		template = get_template('dashboard.html')
		return HttpResponse(template.render(context))
示例#2
0
    def test_auto_assign_bed_on_admission(self):

        patient = Patient(anon_patient_id='12345')
        patient.save()
        submission = Submission(patient=patient)
        submission.save()

        init_hs = InitialHealthSnapshot(
            submission=submission,
            blood_pressure_systolic=3,
            blood_pressure_diastolic=4,
            heart_rate=5,
            breathing_rate=6,
            temperature=7,
            oxygen_saturation=8,
            gcs_eye=1,
            gcs_verbal=12,
            gcs_motor=3,
            observations="Text notes",
            severity=InitialHealthSnapshot.SeverityChoices.YELLOW,
        )

        init_hs.save()

        admission = patient.current_admission
        self.assertTrue(admission)

        bed = admission.current_bed
        self.assertTrue(bed)

        self.assertEqual(bed.bed_type.name, "Intermediate Care")
示例#3
0
    def save(self, user):
        """
        在这里可以统计提交量
        :param user: request.user
        :return: submission object
        """
        try:
            language = self.validated_data['language']
            remote_oj = self.validated_data['remote_oj']
            language_obj = Language.objects.get(oj_name=remote_oj,
                                                oj_language=language)
            submission = Submission(
                code=self.validated_data['code'],
                user=user,
                language=language_obj.oj_language,
                language_name=language_obj.oj_language_name,
                sha256=hashlib.sha256(
                    self.validated_data['code'].encode('utf-8')).hexdigest(),
                remote_id=self.validated_data['remote_id'],
                remote_oj=self.validated_data['remote_oj'])

            submission.save()
            return submission
        except DatabaseError:
            import traceback
            traceback.print_exc()
            return None
示例#4
0
    def test_no_auto_assign_bed_if_no_match(self):

        patient = Patient(anon_patient_id='12346')
        patient.save()
        submission = Submission(patient=patient)
        submission.save()

        init_hs = InitialHealthSnapshot(
            submission=submission,
            blood_pressure_systolic=3,
            blood_pressure_diastolic=4,
            heart_rate=5,
            breathing_rate=6,
            temperature=7,
            oxygen_saturation=8,
            gcs_eye=1,
            gcs_verbal=12,
            gcs_motor=3,
            observations="Text notes",
            severity='BLACK',
        )

        init_hs.save()

        admission = patient.current_admission
        self.assertTrue(admission)

        bed = admission.current_bed
        self.assertFalse(bed)
示例#5
0
文件: tasks.py 项目: zerolfx/eoj3
def judge_submission_on_contest(submission: Submission, callback=None, **kwargs):

    def _callback():
        invalidate_contest_participant(contest, submission.author_id)
        invalidate_contest_problem(contest, submission.problem_id)
        if callback:
            callback()

    contest = submission.contest or kwargs.get('contest')
    sync = kwargs.get('sync', False)
    if contest is None:
        raise ValueError('Judge on "None" contest')
    cases = 'all' if contest.system_tested else contest.run_tests_during_contest
    # print(cases)
    run_until_complete = contest.scoring_method == 'oi' and not submission.problem.group_enabled
    if not submission.contest:
        cases = 'all'
        _callback = None

    if cases != 'none':
        judge_submission_on_problem(submission, callback=_callback, case=cases,
                                    run_until_complete=run_until_complete,
                                    status_for_pretest=cases != 'all', sync=sync)
    else:
        submission.status = SubmissionStatus.SUBMITTED
        submission.save(update_fields=['status'])
        Thread(target=_callback).start()
示例#6
0
def calc_contest_score(sub):
    if not sub.contest:
        return
    z_key = str(sub.contest.pk) + sub.contest.name
    s_key = str(sub.user.pk) + sub.user.username
    u_key = str(sub.contest.pk) + '--' + str(sub.user.pk)
    if not r.get(u_key):
        us = UserSerializer(user_pk=sub.user.pk,
                            user_name=sub.user.user_name,
                            contest_pk=sub.contest.pk,
                            cost_time=0,
                            all_sub=0,
                            problem_ac={},
                            problem_time={},
                            problem_sub={})
    else:
        us = UserSerializer(data=r.get(u_key))
    if not r.zscore(z_key, s_key):
        r.zadd(z_key, s_key=0)
    dura = datetime.now() - sub.contest.start_time
    us.all_sub += 1
    pkey = str(sub.problem.pk)
    us.problem_sub[pkey] += 1
    if Submission.firstAcInContest(sub):
        r.incrby(z_key, s_key, 10000)
        us.problem_ac[pkey] += 1
        us.cost_time += us.problem_time[pkey] + dura
    elif Submission.notAcInContest(sub):
        r.incrby(z_key, s_key, -1)
        us.problem_time[pkey] += timedelta(minute=20)
    r.setex(u_key, 18000, us.toJson())
示例#7
0
文件: views.py 项目: shanzi/checkr
def add(request):
    tip = None
    if request.POST:
        form = AddSubmissionForm(request.POST)
        if form.is_valid():
            student = form.cleaned_data['student']
            assignment = form.cleaned_data['assignment']
            score = form.cleaned_data['score']
            try:
                submission = Submission.objects.get(
                        student=student,
                        assignment=assignment)
            except Exception as e:
                submission = Submission(student=student, assignment=assignment)
            submission.score = score 
            submission.updated_at = timezone.now()
            submission.save()
            tip = 'submit: %s - %s' % (student.name, assignment.title)
    else:
        form = AddSubmissionForm()
        tip = 'Add a new submission!'
        
    return render_to_response(
            'add_submission.html', 
            {'form':form,'title':'Submission::Add', 'tip':tip},
            context_instance=RequestContext(request))
示例#8
0
文件: tests.py 项目: kennym/nejupy
    def test_create_submission(self):
        """ Test creating a submission. """
        source_code = File(open(os.path.join(SOURCE_CODE_DIR, "test.py")))
        submission = Submission(problem=self.problem,
                                participant=self.participant,
                                source_code=source_code,
                                programming_language=4)
        submission.save()

        self.assertIsNotNone(Submission.objects.get(pk=submission.id))
示例#9
0
    def _submit(self):
        print 'submitting: %s' % self.message.subject 
        stu_num, seq, ext = self.attachment_name_split
        student = Student.objects.get(student_num=stu_num)
        assignment = Assignment.objects.get(sequence=seq)
        self.student_name = student.name
        self.assignment_title = assignment.title
        try:
            submission = Submission.objects.get(
                    student=student,
                    assignment=assignment)
            submission.score = self._score(assignment)
        except Exception as e:
            submission = Submission()
            submission.student = student
            submission.assignment = assignment
            submission.score = self._score(assignment)
            submission.updated_at = self.message.parsed_date or datetime.now()
            submission.save()

        email = self._save_email(submission)

        try:
            self._save_files(email, ext)
            submission.save()
        except zipfile.BadZipfile as e:
            self.badattachments = True
            raise e
        except rarfile.BadRarFile as e:
            self.badattachments = True
            raise e

        self.submitted = True

        return True
示例#10
0
def submit(request):
    if not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('index'))
    if request.method == 'POST':
        submissionObject = Submission(
            user=request.user.username,
            problem=request.POST['problem'],
            source=request.POST['source'],
            language=request.POST['lang'],
            stat='',
            queries=2500,
            cpu=99.999,
            memory=999.99,
        )
        if submissionObject.checkSafe() is True:
            submissionObject.stat = 'Safe for compilation'
            submissionObject.save()
            return HttpResponseRedirect(
                reverse('status', args=[submissionObject.id]))
        else:
            submissionObject.stat = 'Library Import Error'
            submissionObject.save()
            return HttpResponseRedirect(reverse('status', args=[0]))
    else:
        raise Http404
示例#11
0
    def post(self, request, *args, **kwargs):
        problem = Problem.objects.get(pk=kwargs.get('pk', None))
        form = SubmissionForm(request.POST, request.FILES)

        if form.is_valid():
            submission = Submission(problem=problem, submitter=request.user.student, code=request.POST['code'],
                                    number=Submission.objects.filter(problem=problem,
                                                                     submitter=request.user.student).count()+1
                                    )
            submission.save()

            return redirect('submission', problem.pk, submission.pk)
        else:
            return redirect('submit', problem.pk)
示例#12
0
文件: views.py 项目: a62625536/qaqoj
def submitProblem(request):
    problem_id = request.GET.get('problem_id')
    try:  #判断目标问题是否存在
        problem = Problem.objects.get(id=problem_id)
    except:
        return redirect('/problems')
    if not request.user.is_authenticated:  #用户未登录
        return redirect('/login')
    else:  #用户已登录
        if not problem.visible and not request.user.is_staff:  #问题不可见且用户不是管理员
            return redirect('/problems')
        else:  #问题可见或用户是管理员
            if request.method == "POST":  #POST请求
                submission = Submission()
                submission.myuser = MyUser.objects.get(user_id=request.user.id)
                submission.problem = problem
                submission.language = request.POST.get('language')
                submission.code = request.POST.get('code')
                submission.myuser.sub_num += 1
                problem.sub_num += 1
                submission.myuser.save()
                problem.save()
                submission.save()
                test_submission.delay(submission.id)
                return redirect('/status')
            else:  #GET请求
                return render(request, 'problem_submit.html')
示例#13
0
文件: views.py 项目: sijiac/BOJ-V4
    def form_valid(self, form):
        self.object = form.save(commit=False)
        sub = Submission()
        sub.code = form.cleaned_data['submission__code']
        sub.language = form.cleaned_data['submission__language']
        sub.user = self.request.user
        sub.problem = self.object.problem.problem
        sub.save()
        sub.judge()
        self.object.submission = sub
        self.object.save()
        # self.object.user = self.request.user

        messages.add_message(self.request, messages.SUCCESS,
                             _('Submit Success'))
        return super(SubmissionCreateView, self).form_valid(form)
示例#14
0
def get_submission_task(submission):
    name = current_process().name
    try:
        submission = parse(**submission)
        sub = Submission(
            **{
                **submission,
                **{
                    'work_dir': path.join(base_work_dir, name),
                    'output_limit': 64,
                    'stack_limit': 64,
                    'sourcefile': 'Main'
                }
            })
        logging.info('%s got submission, start judging(%s)', name,
                     sub.submission)
        judge_submission(sub)
    except Exception as e:
        from update import upload_result
        from report.models import Report
        upload_result(
            Report(result=Judge_result.JE,
                   complete=True,
                   submission=sub.submission,
                   judgererror_msg=str(e)))
        logging.error('%s error happen: %s', name, e)
示例#15
0
文件: views.py 项目: hbatyrkhan/mycms
def problem_page(request, contest_pk, problem_pk):
    if request.method == "POST":
        lang = request.POST.get("sub_language")
        source = request.POST.get("sub_source")
        if lang and source:
            sub = Submission(source=source, language=lang)
            sub.participant = request.user.participant_set.get(
                contest__pk=contest_pk)
            sub.sent_date = timezone.now()
            sub.problem = get_object_or_404(Problem, problem_id=problem_pk)
            problem_infos = ProblemInfo.objects.filter(
                problem=get_object_or_404(Problem, problem_id=problem_pk),
                contest__pk=contest_pk)
            if problem_infos:
                sub.problem_info = problem_infos.first()
            sub.contest = Contest.objects.get(pk=contest_pk)
            sub.save()

            evaluate_submission.delay(sub_pk=sub.pk,
                                      username=request.user.username)

            return redirect('problem-page',
                            contest_pk=contest_pk,
                            problem_pk=problem_pk)

    participant = get_object_or_404(Participant, user=request.user)
    contest = get_object_or_404(Contest, pk=contest_pk)
    problem = get_object_or_404(Problem,
                                problem_id=problem_pk,
                                contests=contest)
    submissions = Submission.objects.filter(contest=contest,
                                            problem=problem,
                                            participant=participant)
    subtasks = problem.subtask_set.all()
    total = 0
    for score in subtasks:
        total += score.points

    # print(RunInfo.objects.all().first().submission.source)
    context = {
        'statement': problem.statement,
        'samples': problem.test_set.filter(in_statement=True),
        'contest': contest,
        'problems': contest.problem_set.all(),
        'submissions': submissions,
        'subtasks': subtasks,
        'total': total,
        'username': request.user.username,
    }

    return render(request, 'problem/problem.html', context)
示例#16
0
文件: tests.py 项目: kennym/nejupy
    def test_source_code_upload_path(self):
        """ Test that source code gets saved in correct path. """
        source_code = File(open(os.path.join(SOURCE_CODE_DIR, "test.py")))
        submission = Submission(problem=self.problem,
                                participant=self.participant,
                                source_code=source_code,
                                programming_language=4)
        submission.save()

        expected_path = os.path.abspath(
            "media/submissions/competition_{cid}/problem_{pid}/user_{uid}/test.py".
            format(
                cid=submission.participant.competition.id,
                pid=submission.problem.id,
                uid=submission.participant.id
            ))
        self.assertEquals(self.submission.source_code.path, expected_path)
示例#17
0
def submitcode(request):
    if request.method == 'POST':
        source_code = SourceCodeForm(request.POST)
        if source_code.is_valid():
            data = source_code.cleaned_data
            cid = int(data['cid'])
            if cid != 0:
                contest = get_object_or_404(Contest, cid=cid)
                now = timezone.now()
                st = contest.start_time
                ed = contest.end_time
                print now, st, ed
                if st > now:
                    return printError('Contest Not Start')
                if now > ed:
                    return printError('Contest alreadly finished')

            submission = Submission(user=request.user,
                                    cid=data['cid'],
                                    pid_id=data['pid'],
                                    code=data['code'],
                                    language=data['language'],
                                    submited_time=datetime.now(),
                                    status=0,
                                    judge_result='Pending',
                                    code_length=len(data['code']))
            submission.code_length = len(submission.code)
            submission.save()

            problem = Problem.objects.get(pid=data['pid'])
            problem.submited += 1
            problem.save()

            user = Handle.objects.get(user=request.user)
            user.submited += 1
            user.save()

            if int(data['cid']) != 0:
                return HttpResponseRedirect('/contest/' + str(data['cid']) +
                                            '/submission')

    return HttpResponseRedirect('/submission/1')
示例#18
0
文件: judge.py 项目: Mr-Phoebe/BOJ-V4
def submit_handler(message):
    print 'submit=================',  message.body
    try:
        mp = json.loads(message.body)
        s = ContestSubmission()
        s.problem = ContestProblem.objects.get(pk=int(mp['problem']))
        sub = Submission()
        sub.code = mp['code']
        sub.language = mp['language']
        sub.problem = s.problem.problem
        sub.user = User.objects.get(pk=int(mp['user']))
        sub.save()
        s.submission = sub
        s.save()
        sub.judge()
    except Exception as ex:
        print ex
    return True
示例#19
0
文件: tasks.py 项目: foreignbill/eoj3
def judge_submission_on_contest(submission: Submission,
                                callback=None,
                                **kwargs):
    def _callback():
        invalidate_contest_participant(contest, submission.author_id)
        if callback:
            callback()

    contest = submission.contest
    cases = 'all' if contest.status > 0 else contest.run_tests_during_contest
    run_until_complete = contest.scoring_method == 'oi'
    if cases != 'none':
        judge_submission_on_problem(submission,
                                    callback=_callback,
                                    case=cases,
                                    status_private=contest.is_frozen,
                                    run_until_complete=run_until_complete,
                                    status_for_pretest=cases != 'all')
    else:
        submission.status = submission.status_private = SubmissionStatus.SUBMITTED
        submission.save(update_fields=['status', 'status_private'])
        Thread(target=_callback).start()
示例#20
0
def test_compile():
    print(
        compile(submission=Submission(
            submission=4,
            language='GNU G++17',
            code=open('testcase/compile_bomb.cpp', "r").read(),
            sourcefile='main-144',
            time_limit=5000,
            memory_limit=64,
            output_limit=64,
            stack_limit=64,
            checker='wcmp',
            problem=1,
        )))
示例#21
0
def Submit(request):
    try:
        if len(json.loads(request.body.decode())['code']) <= 0:
            return HttpResponse(status=400)  # Invalid Code
        sub = Submission(code=json.loads(request.body.decode())['code'],
                         input=json.loads(request.body.decode())['input'],
                         language=json.loads(request.body.decode())['language'])
        sub.save()  # Save the code, input and language to database.
    except:
        return HttpResponse(status=400)  # Invalid code, input or language
    try:
        # Add task to RabbitMQ
        credentials = pika.PlainCredentials('guest', 'guest')
        connection = pika.BlockingConnection(
            pika.ConnectionParameters(os.environ.get('RABBITMQ_HOST', 'localhost'), credentials=credentials))
        channel = connection.channel()
        channel.queue_declare(queue='task_queue', durable=True)
        channel.basic_publish(exchange='',
                              routing_key='task_queue',
                              properties=pika.BasicProperties(delivery_mode=2),
                              body=str(sub.id))
        return JsonResponse({'subid': sub.id})  # Successfully saved to DB and added to RabbitMQ
    except:
        return HttpResponse(status=500)  # Pika or RabbitMQ error
示例#22
0
def test_judge_from_file():
    print(
        judge_submission(submission=Submission(
            submission=10,
            language='GNU G++17',
            code=open('testcase/mle.cpp', "r").read(),
            sourcefile='main',
            time_limit=1494,
            memory_limit=128,
            output_limit=64,
            stack_limit=64,
            checker='wcmp',
            work_dir=path.join(base_work_dir, 'Process-0'),
            problem=1,
        )))
def list_files(request):
    # Handle file upload

    context = RequestContext(request)
    user = request.user
    context["user"] = user

    try:
        submission = Submission.objects.get(pk=user.id)
    except:
        submission = Submission(user=user)
        submission.save()

    if request.method == 'POST':
        # form = SubmissionForm(request.POST, request.FILES)
        if all((x in request.FILES for x in ['app_form', 'app_info', 'con_form'])):
            newdoc = Version(
                application_form=request.FILES['app_form'],
                applicant_info=request.FILES['app_info'],
                consent_form=request.FILES['con_form'],
                submission=submission)
            newdoc.save()
    
    return redirect('dashboard')
示例#24
0
def submit_challenge(request, course_short_title):
    challenge = MainChallenge.objects.get(id=request.GET['id'])
    course = Course.objects.filter(short_title=course_short_title)
    user = CustomUser.objects.get(id=request.user.id)
    point_pot = PointPot.objects.filter(user=user, course=course)[0]
    elaboration = Elaboration.objects.filter(main_challenge=challenge, user=user).latest('creation_date')

    try:
        submission = Submission.objects.get(elaboration=elaboration)
        submission.submission_state = Submission.SUBMISSION_STATE_WAITING_FOR_EVALUATION
        submission.submission_date = submission.submission_date.now(tz=utc)
        submission.save()
        for elaboration_part in ElaborationPart.objects.filter(elaboration=elaboration):
            point_pot.subtract(elaboration_part.elaboration_points)

    except ObjectDoesNotExist:
        submission = Submission(elaboration=elaboration)
        submission.save()
        for elaboration_part in ElaborationPart.objects.filter(elaboration=elaboration):
            point_pot.subtract(elaboration_part.elaboration_points)
            SubmissionPart(submission=submission, elaboration_part=elaboration_part).save()


    return HttpResponse(simplejson.dumps({}, cls=DjangoJSONEncoder), mimetype='application/json')
示例#25
0
def submit(request):
    if not request.user.is_authenticated():
        return HttpResponseRedirect(reverse('index'))
    if request.method == 'POST':
        submissionObject = Submission(
            user= request.user.username,
            problem= request.POST['problem'],
            source= request.POST['source'],
            language= request.POST['lang'],
            stat= '',
            queries= 2500,
            cpu= 99.999,
            memory= 999.99,)
        if submissionObject.checkSafe() is True:
            submissionObject.stat= 'Safe for compilation'
            submissionObject.save()
            return HttpResponseRedirect(reverse('status', args=[submissionObject.id]))
        else:
            submissionObject.stat= 'Library Import Error'
            submissionObject.save()
            return HttpResponseRedirect(reverse('status', args=[0]))
    else:
        raise Http404
示例#26
0
 def mutate(self, info, *args, **kwargs):
     form = SubmitSubmissionForm(kwargs)
     if form.is_valid():
         values = form.cleaned_data
         problem = get_object_or_None(Problem, slug=values['problem_slug'])
         attach_info = SubmissionAttachInfo(
             cases_count=DataService.get_cases_count(problem.pk))
         result = JudgeResultModel(_result=JudgeResult.PD.full)
         sub = Submission(code=values.get('code'),
                          _language=values.get('language'),
                          user=info.context.user,
                          problem=problem)
         attach_info.save()
         result.save()
         sub.attach_info = attach_info
         sub.result = result
         sub.save()
         apply_submission.apply_async(
             args=(sub.get_judge_field(), ),
             queue=settings.JUDGE.get('task_queue'))
         problem.ins_submit_times()
         return SubmitSubmission(pk=sub.pk)
     else:
         raise RuntimeError(form.errors.as_json())
示例#27
0
文件: views.py 项目: modanhan/cpsc471
def submission(request, challenge_id):
    if request.user.id == None:
        return HttpResponse('Please log in.')
    if request.method == 'POST':
        try:
            requestpost = request.POST['choice']
        except:
            return HttpResponse('Please select a language.')
        c = Challenge.objects.get(pk=challenge_id)
        input = request.POST.get('your_solution', None)
        user = User.objects.get(pk=request.user.id)
        s = Submission()
        s.challenge = c
        l = Language.objects.get(pk=request.POST['choice'])
        s.language = l
        s.user = user
        s.timestamp = datetime.datetime.now()
        if c.ans == input:
            # check if never solved
            solve = Submission.objects.filter(user__id=request.user.id).filter(
                challenge__id=challenge_id).filter(result='AC')

            if not solve.exists():
                challengeTopics = ChallengeTopic.objects.all().filter(
                    challenge_id=c.id)
                for ct in challengeTopics:
                    t = Topic.objects.get(pk=ct.topic_id)
                    tr, created = TopicRating.objects.get_or_create(
                        topic=t,
                        user=user,
                        defaults={
                            'rating': 0,
                            'timestamp': datetime.datetime.now(),
                        })
                    if created:
                        tr.rating = 0
                    tr.rating += c.difficulty * ct.weight
                    tr.save()

            if not solve.filter(language__id=l.id).exists():
                lr, created = LanguageRating.objects.get_or_create(
                    language=l,
                    user=user,
                    defaults={
                        'rating': 0,
                        'timestamp': datetime.datetime.now()
                    })
                if created:
                    lr.rating = 0
                lr.rating += c.difficulty
                lr.save()

            s.result = 'AC'
            s.save()
            return redirect('correct/')
        else:
            s.result = 'WA'
            s.save()
            return HttpResponse('You are wrong!')
    else:
        return HttpResponse("Something's wrong.")
示例#28
0
def upload_file():

    try:

        now = datetime.now()

        competitions = [
            c for c in Competition.query.all()
            if (not c.start_on or c.start_on <= now) and (
                not c.end_on or c.end_on >= now)
        ]

        if request.method == 'POST':

            competition_id = request.form.get('competitions')
            if competition_id == None:
                flash('No competition selected')
                return redirect(request.url)

            user_id = login.current_user.id

            # check if the post request has the file part
            if 'file' not in request.files:
                flash('No file part')
                return redirect(request.url)
            file = request.files['file']
            # if user does not select file, browser also
            # submit a empty part without filename
            if file.filename == '':
                flash('No selected file')
                return redirect(request.url)

            # check if the user has made submissions in the past 24h
            if Submission.query.filter_by(user_id=user_id).filter_by(
                    competition_id=competition_id).filter(
                        Submission.submitted_on > now -
                        timedelta(hours=23)).count() > 0:
                flash("You already did a submission in the past 24h.")
                return redirect(request.url)

            if file:

                filename = str(uuid.uuid4()) + ".csv"
                filepath = os.path.join(app.config['UPLOAD_FOLDER'], filename)
                file.save(filepath)

                # save submission
                submission = Submission()
                submission.user_id = login.current_user.id
                submission.competition_id = competition_id
                submission.filename = filename
                (submission.preview_score,
                 submission.score) = get_scores(filepath, competition_id)
                submission.submitted_on = now.replace(microsecond=0)
                submission.comment = request.form.get("comment")
                db.session.add(submission)
                db.session.commit()

                return redirect(url_for('scores'))

        return render_template('submission.html', competitions=competitions)

    except ParsingError as e:
        flash(str(e))
        return redirect(request.url)
示例#29
0
def create_test_challenge(request, course_short_title):
    if request.is_ajax():
        step = request.POST['step']

        if int(step)==0:
            #create a elab+subm
            print('create test elab+subm')

            elaboration = Elaboration(id=10000, main_challenge_id=200, portfolio_id=1, user_id=1)
            elaboration.creation_date=datetime.datetime(2013, 2, 16, 15, 24, 17, 345952, tzinfo=utc)
            elaboration.save()

            elaboration_part = ElaborationPart(elaboration=elaboration, sub_challenge_id=200,
                elaboration_text='this is some test text for subchallenge 1 version 1', elaboration_points=4)
            elaboration_part.save()
            elaboration_part2 = ElaborationPart(elaboration=elaboration, sub_challenge_id=201,
                elaboration_text='this is some test text for subchallenge 2 version 1', elaboration_points=4)
            elaboration_part2.save()
            submission = Submission(id=10000, elaboration=elaboration, submission_date=datetime.datetime(2013, 2, 18, 15, 24, 17, 345952, tzinfo=utc))
            submission.save()

            submission.submission_date = datetime.datetime(2013, 2, 18, 15, 24, 17, 345952, tzinfo=utc)
            submission.save()

            submission_part = SubmissionPart(submission=submission, elaboration_part=elaboration_part)
            submission_part.save()

            submission_part2 = SubmissionPart(submission=submission, elaboration_part=elaboration_part2)
            submission_part2.save()
        elif int(step)==1:
            #create a evaluation
            print('create test evaluation')
            with reversion.create_revision():

                elaboration = Elaboration.objects.get(id=10000)
                elaboration_part = ElaborationPart.objects.get(elaboration=elaboration, sub_challenge_id=200)
                elaboration_part.save()
                elaboration_part2 = ElaborationPart.objects.get(elaboration=elaboration, sub_challenge_id=201)
                elaboration_part2.save()

                submission = Submission.objects.get(id=10000)
                submission.submission_state = Submission.SUBMISSION_STATE_EVALUATED
                submission.save()

                submission_part = SubmissionPart.objects.get(submission=submission, elaboration_part = elaboration_part)
                submission_part2 = SubmissionPart.objects.get(submission=submission, elaboration_part = elaboration_part2)

                submission_part.save()
                submission_part2.save()

                evaluation = Evaluation(id=10000, submission=submission, user_id=2, creation_date=timezone.localtime(timezone.now()), evaluation_state=Evaluation.EVALUATION_STATE_EVALUATION_PUBLISHED)
                evaluation.creation_date=datetime.datetime(2013, 2, 20, 15, 24, 17, 345952, tzinfo=utc)
                evaluation.save()

                eval_part = EvaluationPart(evaluation=evaluation, submission_part=submission_part, feedback='this is version 1 of the evaluation of version 1 of the subchallenge 1', assigned_points=3)
                eval_part.save()

                eval_part2 = EvaluationPart(evaluation=evaluation, submission_part=submission_part2, feedback='this is version 1 of the evaluation of version 1 of the subchallenge 2', assigned_points=2)
                eval_part2.save()

        elif int(step)==2:
            #create a second evaluation
            print('create test 2nd eval')
            with reversion.create_revision():
                submission = Submission.objects.get(id=10000)
                elaboration = Elaboration.objects.get(id=10000)

                elaboration_part = ElaborationPart.objects.get(elaboration=elaboration, sub_challenge_id=200)
                elaboration_part2 = ElaborationPart.objects.get(elaboration=elaboration, sub_challenge_id=201)

                submission_part = SubmissionPart.objects.get(submission=submission, elaboration_part = elaboration_part)
                submission_part2 = SubmissionPart.objects.get(submission=submission, elaboration_part = elaboration_part2)

                evaluation = Evaluation.objects.get(id=10000)
                evaluation.creation_date=datetime.datetime(2013, 2, 22, 15, 24, 17, 345952, tzinfo=utc)
                evaluation.save()

                eval_part = EvaluationPart.objects.get(evaluation=evaluation, submission_part=submission_part)
                eval_part.feedback = 'this is version 2 of the evaluation of version 1 of the subchallenge 1'
                eval_part.assigned_points = 4
                eval_part.save()

                eval_part2 = EvaluationPart.objects.get(evaluation=evaluation, submission_part=submission_part2)
                eval_part2.feedback = 'this is version 2 of the evaluation of version 1 of the subchallenge 2'
                eval_part2.assigned_points = 4
                eval_part2.save()
        elif int(step)==3:
            #revise the submission
            print('revise the subm')

            submission = Submission.objects.get(id=10000)
            submission.submission_state = Submission.SUBMISSION_STATE_BEING_REVISED
            submission.save()
        elif int(step)==4:
            #create a second version of the elab + submit again
            print('create test 2nd elab+subm')
            elaboration = Elaboration.objects.get(id=10000)

            elaboration_part = ElaborationPart.objects.get(elaboration=elaboration, sub_challenge_id=200)
            elaboration_part2 = ElaborationPart.objects.get(elaboration=elaboration, sub_challenge_id=201)

            elaboration_part.elaboration_text = 'this is some test created elaboration for subchallenge 1, version 2'
            elaboration_part.save()

            elaboration_part2.elaboration_text = 'this is some test created elaboration for subchallenge 2, version 2'
            elaboration_part2.save()

            submission = Submission.objects.get(id=10000)
            submission_part = SubmissionPart.objects.get(submission = submission, elaboration_part = elaboration_part)
            submission_part2 = SubmissionPart.objects.get(submission=submission, elaboration_part = elaboration_part2)

            submission.submission_date=datetime.datetime(2013, 2, 24, 15, 24, 17, 345952, tzinfo=utc)
            submission.submission_state = Submission.SUBMISSION_STATE_WAITING_FOR_EVALUATION
            submission.save()
            submission_part.save()
            submission_part2.save()

            """
            evaluation = Evaluation.objects.get(id=10000)
            eval_part = EvaluationPart.objects.get(evaluation=evaluation, submission_part=submission_part)
            eval_part.delete()
            evaluation.delete()
             """

            evaluation = Evaluation.objects.get(id=10000)
            evaluation.creation_date=datetime.datetime(2013, 2, 26, 15, 24, 17, 345952, tzinfo=utc)
            evaluation.evaluation_state=Evaluation.EVALUATION_STATE_NO_EVALUATION
            evaluation.save()

            eval_part = EvaluationPart.objects.get(evaluation=evaluation, submission_part=submission_part)
            eval_part.feedback = ''
            eval_part.assigned_points = None
            eval_part.save()

            eval_part2 = EvaluationPart.objects.get(evaluation=evaluation, submission_part=submission_part2)
            eval_part2.feedback = ''
            eval_part2.assigned_points = None
            eval_part2.save()

        return HttpResponse({}, mimetype='application/json')
示例#30
0
    def create(self,
               submission_id=None,
               seed_params={
                   'seed_id': None,
                   'subreddit': None,
                   'before': None,
                   'after': None
               },
               domain=None,
               max_attempts=3,
               max_interactions=None):

        import time
        t = time.process_time()

        if self.__seed or seed_params.get('seed_id'):
            self.__seed = self.__seed or Seed.objects.get(
                id=seed_params.get('seed_id'))
            self.__redditors = self.__seed.redditors
            self.__r_idx = self.__seed.r_idx
            self.__comments = self.__seed.comments
            self.__submissions = self.__seed.submissions
            self.__subreddit = set(self.__seed.subreddits)
            domain = self.__seed.domain

        else:
            submission = None
            if submission_id:
                try:
                    submission = Submission.objects.get(id=submission_id)
                except ObjectDoesNotExist:
                    submission = self.__search_engine.retrive_submission_by_id(
                        submission_id)

            if not submission:
                submission = self.__search_engine.most_commented_submissions(
                    subreddit=seed_params.get('subreddit'),
                    before=seed_params.get('before'),
                    after=seed_params.get('after'),
                    limit=1)[0]
                try:
                    submission = Submission.objects.get(id=submission['id'])
                except ObjectDoesNotExist:
                    try:
                        submission['subreddit'] = SubReddit.objects.get(
                            name=submission['subreddit'])
                    except ObjectDoesNotExist:
                        subreddit = SubReddit(
                            **self.__search_engine.subreddit_info(
                                submission['subreddit']))
                        subreddit.save()

                        submission['subreddit'] = subreddit

                    try:
                        submission['author'] = RedditUser.objects.get(
                            name=submission['author'])
                    except ObjectDoesNotExist:
                        author = RedditUser(
                            **self.__search_engine.redditor_info(
                                submission['author']))
                        author.save()

                        submission['author'] = author

                    submission = Submission(**submission)
                    submission.save()

            submission_seed = submission.to_dict()
            seed = Seed(seed=submission, domain=domain)
            seed.save()
            self.__seed = seed

            # if submission belongs to any subreddit
            self.__subreddit.add(
                submission_seed['subreddit']
                if submission_seed['subreddit'][:2] != 'u_' else None)

            redditor = submission_seed['author']
            self.__redditors = [redditor.name]
            print(redditor.name)

        attempts = 0
        errors = []

        while self.__r_idx < len(self.__redditors):
            print(len(self.__redditors))

            try:
                redditor = RedditUser.objects.get(
                    name=self.__redditors[self.__r_idx])
            except ObjectDoesNotExist:
                redditor = RedditUser(**self.__search_engine.redditor_info(
                    self.__redditors[self.__r_idx]))
                redditor.save()

            try:
                submissions = self.__search_engine.retrive_redditor_submissions(
                    self.__redditors[self.__r_idx], domain)

                for submission in submissions:
                    submission['author'] = redditor

                    try:
                        submission['subreddit'] = SubReddit.objects.get(
                            name=submission['subreddit'])
                    except ObjectDoesNotExist:
                        subreddit = SubReddit(
                            **self.__search_engine.subreddit_info(
                                submission['subreddit']))
                        subreddit.save()

                        submission['subreddit'] = subreddit
                        self.__subreddit = self.__subreddit | {subreddit.name}

                submission_bulk = [
                    Submission(**submission) for submission in submissions
                ]

                comments = []

                print(time.process_time() - t)
                for i, submission in enumerate(submissions):
                    print("%d/%d" % (i + 1, len(submissions)))
                    submission_comments = self.__search_engine.retrive_submission_comments(
                        submission['id'])

                    for comment in submission_comments:
                        try:
                            comment['author'] = RedditUser.objects.get(
                                name=comment['author'])
                        except ObjectDoesNotExist:
                            try:
                                author = RedditUser(
                                    **self.__search_engine.redditor_info(
                                        comment['author']))
                                author.save()

                                comment['author'] = author

                            except Exception:
                                pass

                        comment['submission'] = Submission(
                            id=comment['submission'])

                    comments += submission_comments
                comments = [
                    comment for comment in comments
                    if not isinstance(comment['author'], str)
                ]
                comment_bulk = [Comment(**comment) for comment in comments]

            except Exception as ex:
                if attempts < max_attempts:
                    attempts += 1

                else:
                    errors.append(self.__redditors[self.__r_idx])
                    attempts = 0
                    self.__r_idx += 1

                continue

            Submission.objects.bulk_create(submission_bulk,
                                           ignore_conflicts=True)
            self.__submissions += [
                submission['id'] for submissions in submissions
            ]
            Comment.objects.bulk_create(comment_bulk, ignore_conflicts=True)
            self.__comments += [comment['id'] for comment in comments]

            self.__redditors += list(
                {comment['author'].name
                 for comment in comments} - set(self.__redditors))

            self.__seed.submissions = self.__submissions
            self.__seed.comments = self.__comments
            self.__seed.redditors = self.__redditors
            self.__seed.subreddits = list(self.__subreddit)
            self.__seed.r_idx = self.__r_idx
            self.__seed.save()

            if max_interactions and self.__r_idx == max_interactions - 1: break

            self.__r_idx += 1
示例#31
0
 def save(self, user):
     self.instance = Submission()
     self.instance.user = user
     return super().save()