def get_submission(
given_name,
description,
technique,
quality_control,
replicate_series,
date_replicate,
note,
publishable,
user,
experiment,
publication_list,
):
# check if submission exist, if so return, if not create new
try:
year_later = datetime.now() + timedelta(days=(1 * 365))
# Get generated id and unique name
generated_id = return_unique_generated_id(Submission.objects.all().count())
name = return_unique_submission_name(generated_id, given_name)
submission = Submission(
generated_id=generated_id,
name=name,
given_name=given_name,
description=description,
publishable=publishable,
date_created=datetime.now(),
date_embargo=year_later,
technique=technique,
quality_control=quality_control,
replicate_series=replicate_series,
date_replicate=date_replicate,
note=note,
)
submission.validate_unique()
submission.save()
submission.experiments.add(experiment)
for publication in publication_list:
submission.publications.add(publication)
# Establish User to Submission relationships
submission_contributor = SubmissionContributor.submission_contributor_objects.create_submission_as_superuser(
submission, user
)
submission_contributor.validate_unique()
submission_contributor.save()
except ValidationError as e:
print e
submission = Submission.objects.get(given_name=given_name)
return submission
def from_data(cls, festhome_data):
submission = Submission(
title=festhome_data.title,
title_en=festhome_data.title_en,
country=COUNTRIES_DICT.get(festhome_data.country, "ZZ"),
section=SECTION_DICT.get(festhome_data.section, 1),
synopsis=festhome_data.synopsis,
length=festhome_data.length,
aspect_ratio=" ",
year=datetime.strptime(festhome_data.date, "%Y-%m-%d").year,
premiere=2, # no
budget=" ",
attend=0,
allow_tv=2,
allow_noncommercial=2,
allow_network=2,
backlink=12, # other
applicant="%s %s" % (festhome_data.applicant_name, festhome_data.applicant_lastname),
applicant_email=festhome_data.applicant_email,
applicant_phone="(%s) %s" % (festhome_data.applicant_code, festhome_data.applicant_phone),
applicant_address="%s, %s, %s, %s"
% (
festhome_data.applicant_street,
festhome_data.applicant_city,
festhome_data.applicant_state,
festhome_data.applicant_country,
),
director="%s %s" % (festhome_data.applicant_name, festhome_data.applicant_lastname),
director_email=festhome_data.applicant_email,
director_address="%s, %s, %s, %s"
% (
festhome_data.applicant_street,
festhome_data.applicant_city,
festhome_data.applicant_state,
festhome_data.applicant_country,
),
comment="Import from Festhome",
)
submission.save()
return cls(submission=submission, festhome_id=festhome_data.festhome_id)
def test_save_unique(self):
exhibition = Exhibition(
title='New Exhibition',
description='description goes here',
released_at=timezone.now(),
author=self.user)
exhibition.save()
artwork = Artwork(title='New Artwork', code='// code goes here', author=self.user)
artwork.save()
submission1 = Submission(exhibition=exhibition, artwork=artwork, submitted_by=self.user)
submission2 = Submission(exhibition=exhibition, artwork=artwork, submitted_by=self.user)
# submissions must be unique
self.assertEqual(submission1.save(), None)
self.assertRaisesRegexp(
IntegrityError,
'columns exhibition_id, artwork_id are not unique',
submission2.save)
class TestCreate(APITestCase):
"""
tests for create
"""
def setUp(self):
self.token = get_auth_token()
self.client.credentials(HTTP_AUTHORIZATION='Bearer ' + str(self.token))
self.create_initial_data()
def create_initial_data(self):
"""
create initials data
:return:
:rtype:
"""
description = """Apply remote sensing principles and methods to analyze
data and solve problems in areas such as natural resource management,
urban planning, or homeland security. May develop new sensor systems,
analytical techniques, or new applications for existing systems."""
self.industry, _ = Industry.objects.get_or_create(
naics_code="313110", industry_type="Fiber, Yarn, and Thread Mills")
self._test_category, _ = JobCategory.objects.get_or_create(
o_net_soc_code="199999999",
category_name="Remote Sensing Scientists and Technologistss")
self._test_category.description = description
self._test_category.save()
self.test_catalog, _ = JobCatalog.objects.get_or_create(
naics_code=self.industry, category=self._test_category)
self.test_job_tag, _ = JobTag.objects.get_or_create(
tag="machine learning")
# self.test_program_id = uuid.uuid4()
self.test_program_id = 'f1a9413d-1ef5-44d6-ac4b-90e4952890be'
self.test_job_title, _ = JobTitle.objects.get_or_create(
program_id=self.test_program_id,
category=self._test_category,
title="software developer555",
level="3",
status=True,
created_by="jai",
modified_by="jai")
self.test_job_config, _ = JobConfiguration.objects.get_or_create(
program_id=self.test_program_id,
config_json={'option': 'unKnown'},
version='test')
self.test_foundation_data, _ = FoundationData.objects.get_or_create(
program_id=self.test_program_id)
current_date = datetime.date.today()
self.test_job, _ = Job.objects.get_or_create(
program_id=self.test_program_id,
config_id=self.test_job_config,
category=self._test_category,
title=self.test_job_title,
no_of_openings=8,
salary_min_range=20000,
salary_max_range=30000,
start_date=current_date,
end_date=current_date + datetime.timedelta(days=1),
foundational=self.test_foundation_data)
self.current_user_id = uuid.uuid4()
self.test_candidate_id = uuid_shuffle(self.current_user_id)
self.test_submission = Submission(
job=self.test_job,
program_id=self.test_program_id,
organization_id='test_organization_id',
candidate_id=self.test_candidate_id,
created_by=self.current_user_id,
modified_by=self.current_user_id)
self.test_submission.save()
self.body = {
"job_template_id": self.test_job.id,
"job_category_id": self._test_category.id,
"job_level": 7,
"job_title_id": self.test_job_title.id,
"min_rate_rule": "Cannot Change",
"max_rate_rule": "Cannot Change",
"min_rate": 75.0,
"max_rate": 88.0,
"currency": "USD",
"work_location": "UP"
}
def test_post_rate_card(self):
"""
post rate card test
"""
url = reverse('rate_card:rate_card_get_list_n_post',
kwargs={'program_id': self.test_program_id})
response = self.client.post(url, self.body, format='json')
data = response.data
self.assertEqual(response.status_code, 201)
self.assertEqual(data["program_id"],
RATE_CARD_POST_RESPONSE["program_id"])
self.assertEqual(data["job_level"],
RATE_CARD_POST_RESPONSE["job_level"])
self.assertEqual(data["min_rate_rule"],
RATE_CARD_POST_RESPONSE["min_rate_rule"])
self.assertEqual(data["max_rate_rule"],
RATE_CARD_POST_RESPONSE["max_rate_rule"])
self.assertEqual(data["min_rate"], RATE_CARD_POST_RESPONSE["min_rate"])
self.assertEqual(data["max_rate"], RATE_CARD_POST_RESPONSE["max_rate"])
self.assertEqual(data["currency"], RATE_CARD_POST_RESPONSE["currency"])
self.assertEqual(data["work_location"],
RATE_CARD_POST_RESPONSE["work_location"])
def test_get_rate_card_list(self):
"""
get rate_card_list
:return:
:rtype:
"""
url = reverse('rate_card:rate_card_get_list_n_post',
kwargs={'program_id': self.test_program_id})
post_response = self.client.post(url, self.body, format='json').data
get_list_response = self.client.get(url,
format='json').data["results"][0]
self.assertEqual(post_response["program_id"],
get_list_response["program_id"])
self.assertEqual(post_response["job_template"]["id"],
get_list_response["job_template"]["id"])
self.assertEqual(post_response["job_category"]["id"],
get_list_response["job_category"]["id"])
self.assertEqual(post_response["job_title"]["id"],
get_list_response["job_title"]["id"])
self.assertEqual(post_response["job_level"],
get_list_response["job_level"])
self.assertEqual(post_response["min_rate_rule"],
get_list_response["min_rate_rule"])
self.assertEqual(post_response["max_rate_rule"],
get_list_response["max_rate_rule"])
self.assertEqual(post_response["min_rate"],
get_list_response["min_rate"])
self.assertEqual(post_response["max_rate"],
get_list_response["max_rate"])
self.assertEqual(post_response["currency"],
get_list_response["currency"])
self.assertEqual(post_response["work_location"],
get_list_response["work_location"])
def test_get_single_rate_card(self):
"""
get single rate_card
:return:
:rtype:
"""
url = reverse('rate_card:rate_card_get_list_n_post',
kwargs={'program_id': self.test_program_id})
post_response = self.client.post(url, self.body, format='json').data
url = reverse('rate_card:rate_card_get_put_del',
kwargs={
'program_id': self.test_program_id,
'pk': post_response["id"]
})
get_single_response = self.client.get(url, format='json').data
self.assertEqual(post_response["program_id"],
get_single_response["program_id"])
self.assertEqual(post_response["job_template"]["id"],
get_single_response["job_template"]["id"])
self.assertEqual(post_response["job_category"]["id"],
get_single_response["job_category"]["id"])
self.assertEqual(post_response["job_title"]["id"],
get_single_response["job_title"]["id"])
self.assertEqual(post_response["job_level"],
get_single_response["job_level"])
self.assertEqual(post_response["min_rate_rule"],
get_single_response["min_rate_rule"])
self.assertEqual(post_response["max_rate_rule"],
get_single_response["max_rate_rule"])
self.assertEqual(post_response["min_rate"],
get_single_response["min_rate"])
self.assertEqual(post_response["max_rate"],
get_single_response["max_rate"])
self.assertEqual(post_response["currency"],
get_single_response["currency"])
self.assertEqual(post_response["work_location"],
get_single_response["work_location"])
def test_update_single_rate_card(self):
"""
update single rate_card
:return:
:rtype:
"""
url = reverse('rate_card:rate_card_get_list_n_post',
kwargs={'program_id': self.test_program_id})
post_response = self.client.post(url, self.body, format='json').data
url = reverse('rate_card:rate_card_get_put_del',
kwargs={
'program_id': self.test_program_id,
'pk': post_response["id"]
})
work_location = self.body["work_location"]
self.body["work_location"] = "New Delhi"
get_single_response = self.client.put(url, self.body,
format='json').data
self.body["work_location"] = work_location
self.assertEqual(post_response["program_id"],
get_single_response["program_id"])
self.assertEqual(post_response["job_template"]["id"],
get_single_response["job_template"]["id"])
self.assertEqual(post_response["job_category"]["id"],
get_single_response["job_category"]["id"])
self.assertEqual(post_response["job_title"]["id"],
get_single_response["job_title"]["id"])
self.assertEqual(post_response["job_level"],
get_single_response["job_level"])
self.assertEqual(post_response["min_rate_rule"],
get_single_response["min_rate_rule"])
self.assertEqual(post_response["max_rate_rule"],
get_single_response["max_rate_rule"])
self.assertEqual(post_response["min_rate"],
get_single_response["min_rate"])
self.assertEqual(post_response["max_rate"],
get_single_response["max_rate"])
self.assertEqual(post_response["currency"],
get_single_response["currency"])
self.assertEqual(get_single_response["work_location"], "New Delhi")
def test_filter_rate_card(self):
"""
filter rate_card
:return:
:rtype:
"""
url = reverse('rate_card:rate_card_get_list_n_post',
kwargs={'program_id': self.test_program_id})
post_response = self.client.post(url, self.body, format='json').data
query_string = {
"job_template_id": self.test_job.id,
"job_category_id": self._test_category.id,
"job_level": 7,
"job_title_id": self.test_job_title.id,
"min_rate_rule": "Cannot Change",
"max_rate_rule": "Cannot Change",
"min_rate": 75.0,
"max_rate": 88.0,
"currency": "USD",
"work_location": "UP"
}
query_string_v2 = "&".join(
["{}={}".format(key, val) for key, val in query_string.items()])
get_list_response = self.client.get(url,
QUERY_STRING=query_string_v2,
format='json')
get_list_response = get_list_response.data["results"][0]
self.assertEqual(post_response["program_id"],
get_list_response["program_id"])
self.assertEqual(post_response["job_template"]["id"],
get_list_response["job_template"]["id"])
self.assertEqual(post_response["job_category"]["id"],
get_list_response["job_category"]["id"])
self.assertEqual(post_response["job_title"]["id"],
get_list_response["job_title"]["id"])
self.assertEqual(post_response["job_level"],
get_list_response["job_level"])
self.assertEqual(post_response["min_rate_rule"],
get_list_response["min_rate_rule"])
self.assertEqual(post_response["max_rate_rule"],
get_list_response["max_rate_rule"])
self.assertEqual(post_response["min_rate"],
get_list_response["min_rate"])
self.assertEqual(post_response["max_rate"],
get_list_response["max_rate"])
self.assertEqual(post_response["currency"],
get_list_response["currency"])
self.assertEqual(post_response["work_location"],
get_list_response["work_location"])
def test_negative_filter_rate_card(self):
"""
negative filter rate_card
:return:
:rtype:
"""
url = reverse('rate_card:rate_card_get_list_n_post',
kwargs={'program_id': self.test_program_id})
post_response = self.client.post(url, self.body, format='json').data
query_string = {
"job_template_id": self.test_job.id,
"job_category_id": self._test_category.id,
"job_level": 7,
"job_title_id": self.test_job_title.id,
"min_rate_rule": "Cannot Change",
"max_rate_rule": "Cannot Change",
"min_rate": 75.0,
"max_rate": 88.0,
"currency": "USD",
"work_location": "Delhi"
}
query_string_v2 = "&".join(
["{}={}".format(key, val) for key, val in query_string.items()])
get_list_response = self.client.get(url,
QUERY_STRING=query_string_v2,
format='json')
get_list_response = get_list_response.data["results"]
self.assertEqual(get_list_response.__len__(), 0)
def upload_submission(request, learner, trigger, no_thumbnail=True):
"""
Handles the upload of the user's submission.
"""
base_dir_for_file_uploads = settings.MEDIA_ROOT
thumbnail_file_name_django = ''
entry_point = trigger.entry_point
files = request.FILES.getlist('file_upload', None)
if files is None:
return None
# Is the storage space reachable?
deepest_dir = base_dir_for_file_uploads + 'uploads/{0}/tmp/'.format(
entry_point.id)
try:
os.makedirs(deepest_dir)
except OSError:
if not os.path.isdir(deepest_dir):
logger.error(
'Cannot create directory for upload: {0}'.format(deepest_dir))
raise
if len(files) == 1:
filename = files[0].name
extension = filename.split('.')[-1].lower()
submitted_file_name_django = 'uploads/{0}/{1}'.format(
entry_point.id,
generate_random_token(token_length=16) + '.' + extension)
full_path = base_dir_for_file_uploads + submitted_file_name_django
with open(full_path, 'wb+') as dst:
for chunk in files[0].chunks():
dst.write(chunk)
f_size = os.path.getsize(full_path)
if f_size > trigger.max_file_upload_size_MB * 1024 * 1024:
logger.warning(
'File too large {0}'.format(submitted_file_name_django))
return None, ('File too large ({0} MB); it must be less than '
'{1} MB.'.format(
round(float(f_size / 1024.0 / 1024.0), 1),
trigger.max_file_upload_size_MB))
else: #if trigger.allow_multiple_files: this is removed for now
filename = ''
extension = ''
submitted_file_name_django = ''
full_path = ''
# Check that the file format is PDF, if that is required.
strike1 = False
if 'pdf' in trigger.accepted_file_types_comma_separated.lower() and \
extension in ('pdf',):
try:
mime = magic.from_file(full_path, mime=True)
if not (isinstance(mime, str)):
mime = mime.decode('utf-8')
except Exception as exp:
logger.error('Could not determine MIME type: ' + str(exp))
mime = ''
strike1 = True
if 'application/pdf' not in mime.lower():
strike1 = True
if strike1:
logger.debug('Invalid PDF upload: {0} [{1}]'.format(
mime, full_path))
#return None, 'Invalid file uploaded. Uploaded file must be a PDF.'
doc = PdfFileReader(full_path)
if doc.isEncrypted:
logger.debug('Encrypted PDF upload: {0}'.format(full_path))
return None, ('An encrypted PDF cannot be uploaded. Please remove '
'the encryption and try again.')
strike1 = False
if (('jpeg' in trigger.accepted_file_types_comma_separated.lower()) or \
('jpg' in trigger.accepted_file_types_comma_separated.lower())) and \
extension in ('jpg', 'jpeg'):
try:
mime = magic.from_file(full_path, mime=True)
if not (isinstance(mime, str)):
mime = mime.decode('utf-8')
except Exception as exp:
logger.error('Could not determine MIME type: ' + str(exp))
mime = ''
strike1 = True
if 'image/jpeg' not in mime.lower():
strike1 = True
if strike1:
logger.debug('Invalid JPG upload: {0} [{1}]'.format(
mime, full_path))
return None, ('Invalid file. Uploaded image should be a valid '
'and readable JPEG file.')
strike1 = False
if ('png' in trigger.accepted_file_types_comma_separated.lower()) and \
extension in ('png',):
try:
mime = magic.from_file(full_path, mime=True)
if not (isinstance(mime, str)):
mime = mime.decode('utf-8')
except Exception as exp:
logger.error('Could not determine MIME type: ' + str(exp))
mime = ''
strike1 = True
if 'image/png' not in mime.lower():
strike1 = True
if strike1:
logger.debug('Invalid PNG upload: {0} [{1}]'.format(
mime, full_path))
return None, ('Invalid file. Uploaded image should be a valid '
'and readable PNG file.')
strike2 = False
if extension.lower() not in \
trigger.accepted_file_types_comma_separated.lower():
logger.debug('Invalid file type upload: received ".{0}"; [{1}]'.format(\
extension, full_path))
return None, ('Invalid file uploaded. Uploaded file must be: {}'.format(\
trigger.accepted_file_types_comma_separated))
if trigger == entry_point:
# In some instances we don't use triggers, just entry_points
prior = Submission.objects.filter(status='S',
submitted_by=learner,
entry_point=entry_point,
is_valid=True)
else:
prior_indiv = Q(status='S',
submitted_by=learner,
entry_point=entry_point,
trigger=trigger,
is_valid=True)
# We need this here, but also for the code later in the next
# if (trigger==entry_point) part
# Default returned by this function is ``None`` if the user is not
# enrolled in a group, or if this course simply does not use groups.
group_submitted = is_group_submission(learner, entry_point)
if is_group_submission(learner, entry_point):
group_submitted = group_submitted.group
prior_group = Q(status='S',
group_submitted=group_submitted,
entry_point=entry_point,
trigger=trigger,
is_valid=True)
else:
prior_group = Q()
prior = Submission.objects.filter(prior_indiv | prior_group)
for item in prior:
logger.debug(('Setting prior submission to False: {0} and name '
'"{1}"'.format(str(item), item.submitted_file_name)))
item.is_valid = False
item.save()
if trigger == entry_point:
# In some instances we don't use triggers, just entry_points
sub = Submission(
submitted_by=learner,
group_submitted=None,
status='S',
entry_point=entry_point,
is_valid=True,
file_upload=submitted_file_name_django,
thumbnail=thumbnail_file_name_django,
submitted_file_name=filename,
ip_address=get_IP_address(request),
)
sub.save()
else:
sub = Submission(
submitted_by=learner,
group_submitted=group_submitted,
status='S',
entry_point=entry_point,
trigger=trigger,
is_valid=True,
file_upload=submitted_file_name_django,
thumbnail=thumbnail_file_name_django,
submitted_file_name=filename,
ip_address=get_IP_address(request),
)
sub.save()
if 'pdf' in trigger.accepted_file_types_comma_separated.lower() and \
extension in ('pdf',):
clean_PDF(sub)
return sub
def post(self, request, pid):
global lang
problem = get_object_or_404(Problem, pk=pid)
if 'lang_select' in request.POST:
form2 = self.form_class2(request.POST)
if form2.is_valid():
lang = form2.cleaned_lang()
form1 = self.form_class1(lang, None)
form2 = self.form_class2(None)
return render(
request, self.template_name, {
'problem': problem,
'form1': form1,
'form2': form2,
'lang': lang
})
else:
form1 = self.form_class1(lang, None)
form2 = self.form_class2(None)
return render(
request, self.template_name, {
'problem': problem,
'form1': form1,
'form2': form2,
'lang': lang
})
else:
form1 = self.form_class1(data=request.POST, lang=lang)
if not form1.is_valid():
form1 = self.form_class1(lang, None)
form2 = self.form_class2(None)
return render(request, self.template_name, {
'form1': form1,
'form2': form2,
'lang': lang
})
content = ContentFile(request.POST['code'])
submission = Submission(user=request.user,
lang=lang,
problem=problem)
submission.code.save('x' + self.lang_map[lang],
content,
save=False)
r = submission.compile()
# Compilation error
if r != 200:
submission.code.delete(save=False)
form2 = self.form_class2(None)
return render(request, self.template_name, {
'form1': form1,
'form2': form2,
'lang': lang,
'errors': r
})
submission.save()
result = problem.test(submission)
result.status = status[result.status]
result.toe = '{:.2f}'.format(result.toe)
form2 = self.form_class2(None)
return render(
request, self.template_name, {
'problem': problem,
'form1': form1,
'form2': form2,
'lang': lang,
'result': result
})
class SubmissionAPIViewTest(APITestCase):
def setUp(self):
self.teacher = User.objects.create(email="*****@*****.**")
self.ta = User.objects.create(email="*****@*****.**")
self.student = User.objects.create(email="*****@*****.**")
self.course = Course.objects.create(
title="Test course",
description="Test description",
)
self.course.add_member(self.teacher, Membership.TEACHER)
self.course.add_member(self.ta, Membership.TA)
self.course.add_member(self.student, Membership.STUDENT)
self.teacher_access_token = AccessToken.for_user(self.teacher)
self.ta_access_token = AccessToken.for_user(self.ta)
self.student_access_token = AccessToken.for_user(self.student)
self.environment = Environment.objects.create(
course=self.course,
title="Test environment",
dockerfile_content=
"FROM python:3.7\nRUN mkdir /src\nWORKDIR /src\n",
tag="test_image",
)
self.assignment = Assignment.objects.create(
course=self.course,
environment=self.environment,
title="Test assignment",
description="Test assignment description",
)
self.rule = Rule.objects.create(
title="Test rule",
description="Test rule description",
order=1,
command="python caesar.py",
timeout=None,
continue_on_fail=True,
assignment=self.assignment,
)
self.submission = Submission(assignment=self.assignment,
user=self.teacher,
repo_url='github.com/terdenan/test-educi',
branch='master')
self.submission.save(download_type=Submission.STRATEGY_REPOSITORY)
self.submission_list_url = reverse('courses:submissions:list',
args=(self.course.id, ))
self.submission_detail_url = reverse('courses:submissions:detail',
args=(
self.course.id,
self.submission.id,
))
def test_can_get_list_of_submissions(self):
self.client.credentials(
HTTP_AUTHORIZATION=f"Bearer {self.teacher_access_token}")
response = self.client.get(self.submission_list_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(len(response.data), 1)
self.assertEqual(response.data[0]['user'], self.teacher.id)
def test_can_get_submission(self):
self.client.credentials(
HTTP_AUTHORIZATION=f"Bearer {self.teacher_access_token}")
response = self.client.get(self.submission_detail_url)
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['user'], self.teacher.id)
def test_can_create_submission(self):
self.client.credentials(
HTTP_AUTHORIZATION=f"Bearer {self.teacher_access_token}")
test_submission = {
'assignment': self.assignment.id,
'repo_url': 'github.com/terdenan/test-educi',
'branch': 'master',
'type': Submission.STRATEGY_REPOSITORY
}
response = self.client.post(self.submission_list_url, test_submission)
self.assertEqual(response.status_code, status.HTTP_201_CREATED)
self.assertEqual(response.data['user'], self.teacher.id)
self.assertEqual(response.data['status'], Submission.PROCESSING)
response = self.client.get(
reverse('courses:submissions:detail',
args=(self.course.id, response.data['id'])))
self.assertEqual(response.status_code, status.HTTP_200_OK)
self.assertEqual(response.data['status'], Submission.PERFORMED)
def problemstmt(request, _id):
# posted the problem
if request.method == 'POST':
# post request
problem = Problem.objects.filter(id=_id)
if not problem.exists():
return HttpResponseNotFound()
if request.user.is_authenticated:
# authentic user
# evaluate the submission
remark = compiler.compilation(request.user.id,
request.POST['lang'],
request.POST['code'], _id)
# messages.success(
# request, 'Submission successful')
userid = request.user.id
lang = request.POST['lang']
code = request.POST['code']
status = remark
# check the previous successful submission
prevsub = Submission.objects.filter(userid=request.user.id).filter(
problemid=_id).filter(status='0')
submission = Submission(userid=userid,
lang=lang,
code=code,
status=status,
problemid=_id)
# submission.save()
problem = problem[0]
problem.attempts = problem.attempts + 1
if status == 0:
# increase problem solves count
problem.successes = problem.successes + 1
# if no previous success
print('got this far-----------------------------')
print('{} has length of solves: {}'.format(
request.user.username, len(prevsub)))
if len(prevsub) == 0:
profile = Profile.objects.filter(user_id=request.user.id)
if profile.exists():
# update the score with correct score
profile = profile[0]
profile.score = profile.score + problem.score
profile.save()
# update the problemsets
# increase the score if success
problem.save()
submission.save()
if remark == 0:
messages.success(request, details[remark])
else:
messages.warning(request, details[remark])
else:
messages.warning(request, 'Required login to submit')
return redirect('/submissions/{}/'.format(submission.id))
# return render(request, 'submissions/submissiondetails.html', {'submission': res})
else:
# get request
# with open('io/problem{}.html'.format(_id), 'r') as rf:
# stmt = rf.read()
problem = Problem.objects.filter(id=_id)
if not problem.exists():
return HttpResponseNotFound()
else:
problem = problem[0]
return render(request, 'problemsets/problemstmt.html',
{'problem': problem})
