def AssignmentMain(assignment_code):
assignment = Assignment.query.filter_by(code=assignment_code).first()
if assignment is None:
flash("No assignment found!", "danger")
return redirect(url_for("home"))
user = GetUser(session["email"])
if not assignment.classroom in user.classrooms:
flash("Access denied to this assigment!", "warning")
return redirect(url_for("home"))
file_name = os.path.join(SUBMISSION_FOLDER, assignment.code,
f"{user.id}_{user.name}.txt")
submission = Submission.query.filter_by(file_name=file_name).first()
# print(assignment.classroom.students)
if request.method == "POST":
if assignment.deadline < datetime.now():
flash("Assignment deadline execeeded!", "danger")
else:
assignment_program = request.form.get('assignment_program')
assignment_lang = request.form.get('assignment_lang')
if not os.path.exists(
os.path.join(SUBMISSION_FOLDER, assignment.code)):
flash("Upload folder not found! Please inform administrator",
"danger")
else:
result = CheckSubmission(assignment_code, assignment_lang,
assignment_program)
if result is None:
flash("Error while submitting assignment!", "warning")
else:
print(file_name)
with open(file_name, "w+") as submission_file:
for line in assignment_program.split("\n"):
submission_file.write(line + "\n")
if submission is None:
submission = Submission(file_name, assignment, \
assignment_lang, result, user)
else:
submission.update(language=assignment_lang,
result=result)
flash("Assignment submitted successfully!", "success")
db.session.add(submission)
db.session.commit()
submission_program = ""
if submission:
with open(file_name, "r") as submission_file:
for line in submission_file.readlines():
submission_program += line
return render_template("assignment/assignment_main.html", assignment=assignment, \
submission_program=submission_program, submission=submission, \
current_time=datetime.now, strftime=lambda x: x.strftime("%a, %d %b %Y at %I:%M %p"), \
os_sep=os.path.sep)
def get_page_submissions(soup):
"""Returns the list of all submissions in the given page.
Parameters
----------
soup : BeautifulSoup
BeautifulSoup object of a page from the hackathon project gallery.
Returns
-------
list
List of Submission objects.
"""
projects_dirty_url = (soup.findAll(
'a', {'class': 'block-wrapper-link fade link-to-software'}))
projects_url = [p.get('href') for p in projects_dirty_url]
projects_title = soup.findAll(
'div',
{'class': 'software-entry-name entry-body'}) #.find_next('h5').text
titles = [p.find_next('h5').text.strip() for p in projects_title]
submissions = []
for title, url_project, (url_video, tags) in list(
zip(titles, projects_url, map(project_data, projects_url))):
submissions.append(Submission(title, url_project, url_video, tags))
return submissions
def post(self, comp_id=None, user_id=None, response=None):
args = self.parser.parse_args()
submission = args["submission"]
if comp_id and user_id is not None:
#TODO: Implement Score evaluation.
comp = Competition.query.filter_by(id=comp_id).first()
public_score = accuracy_score_public(comp.solution, submission, comp.public_ids)
private_score = accuracy_score_private(comp.solution, submission)
submission = Submission(comp_id, user_id, submission, "Submission", public_score, private_score)
data = save_record(submission)
response = ("Submission created successfully", 201)
return make_response(jsonify({
"message": response[0]
}), response[1])
def new(self, project_path, source_directory):
if is_directory(project_path) and self.__isvalid_source(source_directory):
self.__reset()
self.state['project_path'] = project_path
for file in os.listdir(source_directory):
current_path = os.path.join(source_directory, file)
output_path = os.path.join(project_path, remove_ext(get_uin(file)))
# TODO: add support for more file types and change this to account for that
if get_ext(file) == '.zip':
unzip(current_path, output_path)
flatdir(output_path)
self.state['submissions'].append(Submission(output_path))
return self.save() and len(self.state['submissions']) > 0 and self.state['project_path'] != None
else:
return False
def projects(project_name):
"""
Endpoint project testing page.
"""
if project_name not in project_exec_dict.keys():
return f'Project {project_name} does not exist'
if request.method == 'GET':
if g.auth['isAuthenticated']:
user = User.objects.get({ 'email': g.auth['user']['email'] })
return render_template('project.html',
project_name=project_name,
submissions=user.submissions)
else:
return render_template('project.html', project_name=project_name)
if 'src' not in request.files:
return 'name of files should be src'
# generate a temporary unique folder for file upload
temp_dir_name = str(uuid.uuid1())
temp_dir = os.path.join(flask_app.config['UPLOAD_DIR'], temp_dir_name)
os.mkdir(temp_dir)
# remove temp dir and its contents
def clean_temp_dir():
pass
#shutil.rmtree(temp_dir)
# todo; improve this, allow folders, etc.
# # check if a file has an allowed extension
# def is_file_ext_valid(filename, allowed_extensions):
# idx_dot = filename.rfind('.')
# return idx_dot != -1 and filename[idx_dot:].lower() in allowed_extensions
# save all uploaded files to temp folder
uploaded_files = request.files.getlist('src')
for file in uploaded_files:
filename = secure_filename(file.filename)
# # allow .gz, .cpp, and .h files, and makefile
# if (is_file_ext_valid(filename, ['.gz', '.cpp', '.h', '.hpp'])
# or filename.lower() == 'makefile'):
file.save(os.path.join(temp_dir, filename))
# if one file was uploaded, the user should be trying to
# upload a .tar.gz containing their source code
if len(uploaded_files) == 1:
try:
tarfile_path = os.path.join(temp_dir, secure_filename(uploaded_files[0].filename))
# check if the file is valid; is_tarfile returns a boolean and may raise an exception
if not tarfile.is_tarfile(tarfile_path):
raise
tar_obj = tarfile.open(tarfile_path)
# extract all .cpp, .h, files and makefile from tar
valid_files = []
for file in tar_obj.getmembers():
# # do not allow malicious file names
# if file.name != secure_filename(file.name):
# continue
# if (is_file_ext_valid(file.name, ['.cpp', '.h', '.hpp'])
# or file.name.lower() == 'makefile'):
valid_files.append(file)
# extract tar to temp dir
tar_obj.extractall(path=temp_dir, members=valid_files)
except Exception as e:
clean_temp_dir()
return 'invalid .tar.gz'
# run make
make_process = subprocess.Popen(
'make',
shell=True,
cwd=temp_dir,
universal_newlines=True,
stderr=subprocess.PIPE)
make_process.wait()
# check for compilation error
if make_process.returncode != 0:
clean_temp_dir()
stderr = make_process.stderr
err = []
while True:
err_line = stderr.readline()
if err_line == '':
break
err.append(err_line)
return render_template(
'compilefail.html',
error=err)
# computes an array of (testXX.in, testXX.out) pairs.
def get_test_cases_for_project(project):
p = os.path.join(test_cases_base_dir, project)
files = [f for f in os.listdir(p) if os.path.isfile(os.path.join(p, f))]
files.sort()
ret = []
if len(files) % 2 != 0:
return ret
it = iter(files)
for curr in it:
ret.append((curr, next(it)))
return ret
# iterate through each test case and compare with program output
test_case_data = []
test_case_files = get_test_cases_for_project(project_name)
test_case_num = 0
num_test_cases = len(test_case_files)
num_passed = 0
for test_case_in_file, test_case_out_file in test_case_files:
# pipe test case to program
test_case_in = subprocess.Popen(
['cat', os.path.join(test_cases_base_dir, project_name, test_case_in_file)],
universal_newlines=True,
stdout=subprocess.PIPE)
test_case_in.wait()
test_process = subprocess.Popen(
f'./{project_exec_dict[project_name]}',
shell=True,
cwd=temp_dir,
stdin=test_case_in.stdout,
universal_newlines=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
test_case_num += 1
# attempt to run the test case with a time limit of 1.0s
try:
test_process.wait(timeout=1.0)
except TimeoutExpired as e:
test_case_data.append(TestCaseData(
num=test_case_num,
success=False, timed_out=True))
continue
prog_output = test_process.stdout
expected_output_lines = []
actual_output_lines = []
success = True
with open(os.path.join(test_cases_base_dir, project_name, test_case_out_file)) as test_case_out:
# compare test case output and program output line by line
while True:
test_case_line = test_case_out.readline()
prog_output_line = prog_output.readline()
if test_case_line == '' and prog_output_line == '':
if success:
num_passed += 1
break
if test_case_line != prog_output_line:
success = False
expected_output_lines.append(test_case_line)
actual_output_lines.append(prog_output_line)
test_case_data.append(TestCaseData(
num=test_case_num, success=success,
expected=expected_output_lines,
actual=actual_output_lines))
clean_temp_dir()
# save submission if user is logged in
if g.auth['isAuthenticated']:
submission = Submission(
created_date=datetime.now(),
project_name=project_name,
num_test_cases=num_test_cases,
num_passed=num_passed,
num_failed=num_test_cases-num_passed).save()
user = User.objects.get({ 'email': g.auth['user']['email'] })
user.submissions.append(submission)
user.save()
print(num_passed, num_test_cases)
return render_template(
'testcases.html',
test_cases=test_case_data,
all_passed=num_passed==num_test_cases)
def fetch_rows(table, criteria, connection):
objs = []
try:
cur = connection.cursor()
#--- SPLIT NULLS FROM NOT NULLS + COMMON WORK---#
null_criteria = {}
deleters = []
for key in criteria:
if (criteria[key] is None):
null_criteria[key] = None
deleters.append(key)
for key in deleters:
criteria.pop(key, None)
null_phrase = ('IS NULL AND '.join(null_criteria.keys())) + " IS NULL "
not_null_phrase = '= %s AND '.join(criteria.keys()) + "= %s"
if (null_criteria and not criteria):
crit_phrase = " WHERE " + null_phrase
elif (criteria and not null_criteria):
crit_phrase = " WHERE " + not_null_phrase
elif (criteria and null_criteria):
crit_phrase = " WHERE " + null_phrase + "AND " + not_null_phrase
else:
crit_phrase = ""
#--------------------------------#
if (table == "in"):
select_phrase = "SELECT * FROM instructors"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
instructor = Instructor(row[0], row[1], row[2], row[3], row[4],
row[5], row[6])
objs.append(instructor)
row = cur.fetchone()
if (table == "co"):
select_phrase = "SELECT * FROM courses"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
course = Course(row[0], row[1], row[2], row[3], row[4], row[5],
row[6], row[7], row[8])
objs.append(course)
row = cur.fetchone()
if (table == "st"):
select_phrase = "SELECT * FROM students"
sql = select_phrase + crit_phrase
#print(cur.mogrify(sql, (list(criteria.values()))))
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
student = Student(row[0], row[1], row[2], row[3], row[4],
row[5])
objs.append(student)
row = cur.fetchone()
if (table == "cs"):
select_phrase = "SELECT * FROM coursestudents"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
coursestudent = Coursestudent(row[0], row[1])
objs.append(coursestudent)
row = cur.fetchone()
if (table == "as"):
select_phrase = "SELECT * FROM assignments"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
assignment = Assignment(row[0], row[1], row[2], row[3], row[4],
row[5], row[6], row[7], row[8], row[9])
objs.append(assignment)
row = cur.fetchone()
if (table == "su"):
select_phrase = "SELECT * FROM submissions"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
submission = Submission(row[0], row[1], row[2], row[3], row[4],
row[5], row[6], row[7])
objs.append(submission)
row = cur.fetchone()
if (table == "com"):
select_phrase = "SELECT * FROM comments"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
comment = Comment(row[0], row[1], row[2], row[3])
objs.append(comment)
row = cur.fetchone()
connection.commit()
cur.close()
except Exception as error:
print(error)
return objs
def convert_to_submission(reddit_sub):
return Submission(reddit_sub.id, reddit_sub.title, reddit_sub.ups,
reddit_sub.downs, reddit_sub.author.name, reddit_sub.url)