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
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)
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)
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
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')
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")
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)
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,
)))
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)
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 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)
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')
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
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())
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.")
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)
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
def save(self, user):
self.instance = Submission()
self.instance.user = user
return super().save()
