def new():
try:
users = User.query.filter(User.is_active == True).all()
form = Form_Record_Add(request.form)
sections = Section.query.filter(Section.is_active == True).all()
items = Item.query.filter(Item.is_active == True).all()
if request.method == 'POST':
if form.validate():
sections = Section()
sanitize_form = {
'slug': form.slug.data,
'parent': form.parent.data,
'title_en_US': form.title_en_US.data,
'title_fr_FR': form.title_fr_FR.data,
'description_en_US': form.description_en_US.data,
'description_fr_FR': form.description_fr_FR.data,
'users': form.users.data,
'items': form.items.data,
'is_active': form.is_active.data
}
Section().create_data(sanitize_form)
logger.info("Adding a new record.")
if request_wants_json():
return jsonify(data={
message: "Record added successfully.",
form: form
}), 200, {
'Content-Type': 'application/json'
}
else:
flash("Record added successfully.", category="success")
return redirect("/sections")
form.action = url_for('sections_page.new')
# html or Json response
if request_wants_json():
return jsonify(data=form), 200, {
'Content-Type': 'application/json'
}
else:
return render_template("sections/edit.html",
form=form,
sections=sections,
items=items,
users=users,
title_en_US='New',
app=app)
except Exception, ex:
print("------------ ERROR ------------\n" + str(ex.message))
flash(str(ex.message), category="warning")
abort(404)
def post(self, request):
response_data = {'retCode': error_constants.ERR_STATUS_SUCCESS[0],
'retMsg': error_constants.ERR_STATUS_SUCCESS[1]}
try:
road_id = int(request.POST.get('roadId', 0))
district_id = int(request.POST.get('districtId'))
name = request.POST.get('name')
start_place = request.POST.get('startPlace')
end_place = request.POST.get('endPlace')
xy_coordinate = request.POST.get('XYCOORDINATE', '')
channel = request.POST.get('channel', '')
call_sign = request.POST.get('callSign', '')
remark_1 = request.POST.get('remark1', '')
remark_2 = request.POST.get('remark2', '')
remark_3 = request.POST.get('remark3', '')
except Exception as ex:
print 'function name: ', __name__
print Exception, ":", ex
return generate_error_response(error_constants.ERR_INVALID_PARAMETER, status.HTTP_400_BAD_REQUEST)
if road_id:
cur_section = Section(name=name, start_place=start_place, end_place=end_place,
xy_coordinate=xy_coordinate, road_id=road_id, channel=channel,
call_sign=call_sign, remark1=remark_1, remark2=remark_2,
remark3=remark_3, district_id=Road.objects.get(id=road_id).district_id)
try:
with transaction.atomic():
cur_section.save()
except Exception as ex:
print 'function name: ', __name__
print Exception, ":", ex
return generate_error_response(error_constants.ERR_SAVE_INFO_FAIL,
status.HTTP_500_INTERNAL_SERVER_ERROR)
update_road_section_ids(road_id, cur_section.id, True)
else:
cur_section = Section(name=name, start_place=start_place,
end_place=end_place, xy_coordinate=xy_coordinate,
remark1=remark_1, channel=channel, call_sign=call_sign,
remark2=remark_2, remark3=remark_3, district_id=district_id)
try:
with transaction.atomic():
cur_section.save()
except Exception as ex:
print 'function name: ', __name__
print Exception, ":", ex
return generate_error_response(error_constants.ERR_SAVE_INFO_FAIL,
status.HTTP_500_INTERNAL_SERVER_ERROR)
return Response(response_data, status=status.HTTP_200_OK)
def section_save(section_key_us=None):
form = SectionFormAdmin()
# form validation
if not form.validate_on_submit():
return "VALIDATION_ERROR", 400
# get and validate parent section
if form.parent_section.data == '/':
parent_section_key = None
else:
parent_section = ndb.Key(
urlsafe=form.parent_section.data).get() or abort(404)
parent_section_key = parent_section.key
# section instance
if section_key_us:
# edit
# print 'admin section save EDIT'
section = ndb.Key(urlsafe=section_key_us).get() or abort(404)
else:
# new
# print 'admin section save NEW'
section = Section()
# update data
g.cache.clear()
section.parent_section = parent_section_key
section.set_name(form.name.data, g.language)
section.put()
return 'ok'
def eval(ast, document, last_create=None):
head, *tail = ast
if head[0] == 'section':
section = Section(head[1].rstrip())
document.sections.append(section)
if tail:
eval(tail, document, 'section')
elif head[0] == 'subsection':
subsection = Subsection(head[1].rstrip())
document.sections[-1].subsections.append(subsection)
if tail:
eval(tail, document, 'subsection')
elif head[0] == 'attr':
value = tail[0][1].replace('{', "")
value = value.replace('}', "")
value = value.replace('\t', "")
attr = ({head[1]: (value).rstrip()})
if last_create == 'section':
document.sections[-1].attrs.append(attr)
else:
document.sections[-1].subsections[-1].attrs.append(attr)
else:
eval(head, document, last_create)
if tail:
eval(tail, document, last_create)
def destroy(id=1):
try:
sections = Section()
section = sections.query.get_or_404(id)
if section.children:
# html or Json response
if request_wants_json():
return jsonify(data={
message:
"Unauthorized : Must delete child's section' first"
}), 422, {
'Content-Type': 'application/json'
}
else:
flash("Unauthorized : Must delete child's section first.",
category="danger")
return redirect(url_for('sections_page.index'))
else:
sections.destroy_data(section.id)
# html or Json response
if request_wants_json():
return jsonify(data={
message: "Record deleted successfully.",
section: m_section
})
else:
flash("Record deleted successfully.", category="success")
return redirect(url_for('sections_page.index'))
except Exception, ex:
print("------------ ERROR ------------\n" + str(ex.message))
flash(str(ex.message), category="warning")
abort(404)
def get_all_sections():
"""Get all sections"""
return {
"sections": [
Section(id=ind, name=section, slug=slug)
for ind, (slug, section) in enumerate(slug_to_section.items())
]
}
def import_sections(sheet_url):
index = read_spreadsheet(course="cs61a", url=sheet_url, sheet_name="Index")
header = index[0][:4]
if header != ["Day", "Start Time", "End Time", "Sheet"]:
raise Failure("Invalid header for index sheet")
for day, start_time, end_time, sheet, *args in index[1:]:
sheet: List[List[Union[str, int]]] = read_spreadsheet(
course="cs61a", url=sheet_url, sheet_name=repr(sheet)
)
header = sheet[0]
name_col = header.index("Name")
email_col = header.index("Email")
day = list(calendar.day_name).index(day)
start_time = datetime.strptime(start_time, "%I:%M %p")
start_time = start_time.replace(
year=datetime.now().year,
month=datetime.now().month,
day=datetime.now().day,
)
while start_time.weekday() != day:
start_time += timedelta(days=1)
end_time = datetime.strptime(end_time, "%I:%M %p")
end_time = end_time.replace(
year=start_time.year, month=start_time.month, day=start_time.day
)
pst = pytz.timezone("US/Pacific")
start_time = pst.localize(start_time).timestamp()
end_time = pst.localize(end_time).timestamp()
for section in sheet[1:]:
tutor_name = section[name_col]
tutor_email = section[email_col]
if not tutor_name or not tutor_email:
continue
tutor_user = User.query.filter_by(email=tutor_email).one_or_none()
if tutor_user is None:
tutor_user = User(email=tutor_email, name=tutor_name, is_staff=True)
db.session.add(tutor_user)
tutor_user.is_staff = True
capacity = sum(1 for col in header if "Student" in col)
db.session.add(
Section(
start_time=start_time,
end_time=end_time,
capacity=capacity,
staff=tutor_user,
)
)
db.session.commit()
return refresh_state()
def add_section():
if request.method == "POST":
title = request.form['title']
description = request.form['description']
new_section = Section(title=title, description=description)
db.session.add(new_section)
db.session.commit()
return redirect(url_for('admin_bag'))
return render_template('add_section.html')
def addsection():
if not g.user: # not logged in
return redirect(url_for('home'))
desc = request.form['description']
if desc == '':
flash('error: must enter a title')
else:
db.session.add(Section(desc, session['user_id'],
request.form['color']))
db.session.commit()
flash('added section')
return redirect(url_for('sections'))
def show(id=1):
try:
m_sections = Section()
m_section = m_sections.read_data(id)
# html or Json response
if request_wants_json():
return jsonify(data=m_section)
else:
return render_template("sections/show.html",
section=m_section,
app=app)
except Exception, ex:
print("------------ ERROR ------------\n" + str(ex.message))
flash(str(ex.message), category="warning")
abort(404)
def post(self, request):
response_data = {'retCode': error_constants.ERR_STATUS_SUCCESS[0],
'retMsg': error_constants.ERR_STATUS_SUCCESS[1]}
try:
section_id = int(request.POST.get('sectionId'))
name = request.POST.get('name')
start_place = request.POST.get('startPlace')
end_place = request.POST.get('endPlace')
xy_coordinate = request.POST.get('XYCOORDINATE', '')
channel = request.POST.get('channel', '')
call_sign = request.POST.get('callSign', '')
remark_1 = request.POST.get('remark1', '')
remark_2 = request.POST.get('remark2', '')
remark_3 = request.POST.get('remark3', '')
except Exception as ex:
print 'function name: ', __name__
print Exception, ":", ex
return generate_error_response(error_constants.ERR_INVALID_PARAMETER, status.HTTP_400_BAD_REQUEST)
cur_section = Section.objects.get(id=section_id)
district_id = cur_section.district_id
new_section = Section(name=name, start_place=start_place, channel=channel, call_sign=call_sign,
end_place=end_place, xy_coordinate=xy_coordinate,
remark1=remark_1, remark2=remark_2, remark3=remark_3,
district_id=district_id)
try:
with transaction.atomic():
new_section.save()
except Exception as ex:
print 'function name: ', __name__
print Exception, ":", ex
return generate_error_response(error_constants.ERR_SAVE_INFO_FAIL,
status.HTTP_500_INTERNAL_SERVER_ERROR)
chief = cur_section.chief.all()
bureau = cur_section.exec_chief_sub_bureau.all()
trans = cur_section.exec_chief_trans.all()
arm_poli = cur_section.exec_chief_armed_poli.all()
for item in chief:
new_section.chief.add(item)
for item in bureau:
new_section.exec_chief_sub_bureau.add(item)
for item in trans:
new_section.exec_chief_trans.add(item)
for item in arm_poli:
new_section.exec_chief_armed_poli.add(item)
# 复制段时将岗及人员全部复制关联
copy_station_to_new_section(new_section, cur_section)
return Response(response_data, status.HTTP_200_OK)
def sections(request):
if request.method == 'POST':
# save new post
heading = request.POST['heading']
content = request.POST['content']
section = Section(heading=heading)
section.heading = heading
# section.content = cgi.escape(content).encode("ascii", "xmlcharrefreplace")
section.content = content
section.save()
# Get all sections from DB
sections = Section.objects
return render_to_response('admin/index.html', {'Sections': sections},
context_instance=RequestContext(request))
def restore_object(self, attrs, instance=None):
classgroup = attrs.get('classgroup')
name = attrs.get('name')
user = self.context['request'].user
if instance is None:
instance = Section(classgroup=classgroup,
name=alphanumeric_name(name),
display_name=name)
instance.save()
else:
if not ClassGroupPermissions.is_teacher(classgroup, user):
raise serializers.ValidationError(
"You do not have permission to modify this section.")
instance.name = alphanumeric_name(name)
instance.display_name = name
return instance
def index(page=1):
try:
m_sections = Section()
list_sections = m_sections.all_data(page,
app.config['LISTINGS_PER_PAGE'])
# html or Json response
if request_wants_json():
return jsonify([{
'id': d.id,
'title_en_US': d.title_en_US,
'description_en_US': d.description_en_US,
'title_fr_FR': d.title_fr_FR,
'description_fr_FR': d.description_fr_FR
} for d in list_sections.items])
else:
return render_template("sections/index.html",
list_sections=list_sections,
app=app)
except Exception, ex:
print("------------ ERROR ------------\n" + str(ex.message))
def create_sections_for_programs(programs, activities):
for prog in programs:
for i in range(programs[prog]['num_sections']):
section_id = generate_random_uuid()
section_name = prog + " section " + str(i)
section = Section(section_id=section_id,
name=section_name,
description=section_name,
overview_image=section_name + ".png")
add_and_commit(section)
prog_section_mapping = ProgramSectionMapping(
mapping_id=generate_random_uuid(),
program_id=programs[prog]['program_id'],
section_id=section_id,
order_index=i + 1)
add_and_commit(prog_section_mapping)
for activity_id in activities:
section_activity_mapping = SectionActivityMapping(
mapping_id=generate_random_uuid(),
section_id=section_id,
activity_id=activity_id)
def manage_sections(request):
"""
Render the page where instructors can go to make a new section or
edit existing ones.
"""
if request.method == "POST":
# Class is being submitted
form = NewSectionForm(request.POST)
if form.is_valid():
name = form.cleaned_data["name"]
new_section = Section(name=name)
new_section.save()
return HttpResponseRedirect("/managesection/")
form = NewSectionForm()
sections = Section.objects.all()
context = {
"form": form,
"sections": sections,
"listSize": sections.count()
}
return render(request, "managesection.html", context)
def import_sections(sheet_url):
index = read_spreadsheet(course="cs61a",
url=sheet_url,
sheet_name="Index")
header = index[0][:7]
if header != [
"ID",
"Day",
"Start Time",
"End Time",
"Staff Name",
"Staff Email",
"Label",
]:
raise Failure("Invalid header for index sheet")
for (
id,
day,
start_time,
end_time,
staff_name,
staff_email,
label,
*args,
) in index[1:]:
day = list(calendar.day_name).index(day)
start_time = datetime.strptime(start_time, "%I:%M %p")
start_time = start_time.replace(
year=datetime.now().year,
month=datetime.now().month,
day=datetime.now().day,
)
while start_time.weekday() != day:
start_time += timedelta(days=1)
end_time = datetime.strptime(end_time, "%I:%M %p")
end_time = end_time.replace(year=start_time.year,
month=start_time.month,
day=start_time.day)
pst = pytz.timezone("US/Pacific")
start_time = pst.localize(start_time).timestamp()
end_time = pst.localize(end_time).timestamp()
staff_user = User.query.filter_by(email=staff_email).one_or_none()
if staff_user is None:
staff_user = User(email=staff_email,
name=staff_name,
is_staff=True)
db.session.add(staff_user)
staff_user.is_staff = True
sheet: List[List[Union[str, int]]] = read_spreadsheet(
course="cs61a", url=sheet_url, sheet_name=str(id))
header = sheet[0]
email_col = header.index("Email")
students = [student[email_col] for student in sheet[1:]]
capacity = len(students) * 2
section = Section.query.filter_by(id=id).one_or_none()
if not section:
section = Section(
start_time=start_time,
end_time=end_time,
capacity=capacity,
staff=staff_user,
tag_string=label,
)
db.session.add(section)
for student in students:
user = User.query.filter_by(email=student).one_or_none()
if not user:
user = User(email=student, name=student, is_staff=False)
db.session.add(user)
user.sections = [section]
user.is_staff = False
db.session.commit()
return refresh_state()
def naive_parser(cls, plaintext):
"""
First categorize lines
- detect via short words with longer spaces = chord_line
- detect via known chord words
Then create verses
- detect via enumeration prefixes `1.` + `R:`
- detect via empty line
Then analyze lines to assing chord position.
"""
store = LineStore.from_plaintext(plaintext)
if store.first_line_is_empty:
raise RuntimeError("Naive parser error - first line is empty")
# first line has to be chords in this naive approach
if store.first_line_is_chord:
raise RuntimeError("Naive parser error - first line not chords")
# check if the line categories are zigzag
if not store.lines_are_zigzag:
raise RuntimeError("Naive parser error - line categories not zigzag")
print("line categories are switching per each line, yay")
# generate verse_lines
sections = []
verse_lines = []
line_pairs = store.get_line_pairs()
for i, line_pair in enumerate(line_pairs):
chord_line, text_line = line_pair
verse_line = VerseLineFactory.from_plaintext(chord_line.line, text_line.line)
verse_lines.append(verse_line)
verse_code = text_line.verse_code
save_section = False
if i+1 < len(line_pairs):
next_line = line_pairs[i+1]
next_line_is_new_verse = next_line[1].is_leading_line
if next_line_is_new_verse:
save_section = True
else:
# this is last line_pair
save_section = True
if save_section:
section = Section(
category=SectionCategoryFactory.from_verse_code(verse_code),
verse_code=verse_code,
lines=verse_lines,
)
sections.append(section)
# empty the list to store only verse_lines of the next verse
verse_lines = []
song = Song(
format_version=SongFormatVersion.v0_1_0,
name="noha_v_dumku.lorem",
slug="noha_v_dumku.lorem",
author="SCRAPER",
language="cz",
sections=sections
)
return song
def test_exam_endpoints(self):
user = rand.user()
course = Course(name='World Lit')
section1 = Section(name='Hour 1')
section2 = Section(name='Hour 2')
course.sections = [section1, section2]
exam1 = Exam(name='Exam 1', exam_format='DDD..EEDD')
exam2 = Exam(name='Exam 2', exam_format='..FFFFFFFFFFFF')
course.exams = [exam1, exam2]
user.courses.append(course)
db.session.add(course)
db.session.add_all([user, section1, section2, exam1, exam2])
db.session.commit()
db.session.refresh(course)
db.session.refresh(exam1)
##############################################
# Verify that we have two exams in this course
exams_list_response = self.client.get(
'/api/course/{course_id}/exams'.format(course_id=course.id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
self.assertEqual(exams_list_response.status_code, HTTPStatus.OK)
exam_list_data = json.loads(exams_list_response.data.decode())
self.assertEqual(len(exam_list_data['exams']), 2)
###############################################
# Verify that a specific exam has the correct name and format
self.assertIn('Exam 1',
[exam['name'] for exam in exam_list_data['exams']])
self.assertNotIn('Exam Foo',
[exam['name'] for exam in exam_list_data['exams']])
self.assertIn(
'DDD..EEDD',
[exam['exam_format'] for exam in exam_list_data['exams']])
###############################################
# Add an Exam
new_exam = Exam(name='Exam 3', exam_format='DDDDD')
new_exam_request_response = self.client.post(
'/api/course/{course_id}/exam/add'.format(course_id=course.id),
data=json.dumps(new_exam.toJSON()),
content_type='application/json',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
self.assertEqual(new_exam_request_response.status_code, HTTPStatus.OK)
exams_list_response = self.client.get(
'/api/course/{course_id}/exams'.format(course_id=course.id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
exam_list_data = json.loads(exams_list_response.data.decode())
# we now have 3 exams
self.assertEqual(len(exam_list_data['exams']), 3)
new_exam_id = json.loads(
new_exam_request_response.data.decode())['exam']['id']
###############################################
# Edit an exam
update_exam_response = self.client.post(
'/api/course/{course_id}/exam/{exam_id}/update'.format(
course_id=course.id, exam_id=new_exam_id),
data=json.dumps({
'name': 'Exam 4',
'exam_format': 'CCC'
}),
content_type='application/json',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
self.assertEqual(update_exam_response.status_code, HTTPStatus.OK)
update_exam_response_data = json.loads(
update_exam_response.data.decode())
self.assertEqual('CCC',
update_exam_response_data['exam']['exam_format'])
self.assertEqual('Exam 4', update_exam_response_data['exam']['name'])
###############################################
# Delete an Exam
delete_exam_response = self.client.delete(
'/api/course/{course_id}/exam/{exam_id}'.format(
course_id=course.id, exam_id=new_exam_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
exams_list_response = self.client.get(
'/api/course/{course_id}/exams'.format(course_id=course.id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
exam_list_data = json.loads(exams_list_response.data.decode())
# we should be back to two exams
self.assertEqual(len(exam_list_data['exams']), 2)
###############################################
###############################################
# Create three student exams
for answers in ['DDDTTEEDD', 'ABCTFDEAC', 'DCBFFEAAA']:
create_student_exam_response = self.client.post(
'/api/course/{course_id}/exam/{exam_id}/student_exam'.format(
course_id=course.id, exam_id=exam1.id),
data=json.dumps({'answers': answers}),
content_type='application/json',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
exam1 = Exam.query.get(
exam1.id
) # 'db.session.refresh' doesn't work here, as we're on to a different db session
self.assertEqual(len(exam1.student_exams), 3)
exam_response = self.client.get(
'/api/course/{course_id}/exam/{exam_id}'.format(
course_id=course.id, exam_id=exam1.id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
exam_response_data = json.loads(exam_response.data.decode())
self.assertEqual(len(exam_response_data['exam']['student_exams']), 3)
###############################################
# Update one of those student exams
student_exam_id = exam_response_data['exam']['student_exams'][0]['id']
self.client.post(
'/api/course/{course_id}/exam/{exam_id}/student_exam/{student_exam_id}'
.format(course_id=course.id,
exam_id=exam1.id,
student_exam_id=student_exam_id),
data=json.dumps({'answers': 'AAAFFAAAA'}),
content_type='application/json',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
student_exam = StudentExam.query.get(student_exam_id)
self.assertEqual(student_exam.answers, 'AAAFFAAAA')
###############################################
# Delete a student exam
delete_student_exam_response = self.client.delete(
'/api/course/{course_id}/exam/{exam_id}/student_exam/{student_exam_id}'
.format(course_id=course.id,
exam_id=exam1.id,
student_exam_id=student_exam_id),
content_type='application/json',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
exam1 = Exam.query.get(exam1.id)
self.assertEqual(len(exam1.student_exams), 2)
for row in reader[1:]:
name, email, time, group, is_npe = row
is_npe = is_npe == "TRUE"
hour, mins = time.split(":")
hour = int(hour)
mins = int(mins)
start_time = pst.localize(
datetime(year=2020, month=8, day=26, hour=hour + 12, minute=mins))
end_time = start_time + timedelta(minutes=25)
if email not in users:
users[email] = User(email=email, name=name, is_staff=True)
section = Section(
start_time=start_time.timestamp(),
end_time=end_time.timestamp(),
capacity=5,
staff=users[email],
)
if is_npe:
section.tags = ["NPE"]
lookup[time, group] = section
db.session.add(section)
with open("student_tutorials.csv") as f:
reader = list(csv.reader(f))
for row in reader[1:]:
name, email, time, group = row
def section(self):
return Section(name=self.letters())
def submit2():
#Checks if form1data has been submitted before accessing this page
if not session['form1data']:
return redirect(url_for('submit'))
#Session variable back is decremented
session['back'] = session['back'] - 1
form = SubmitForm2()
form1data = json.loads(session['form1data'])
url_or_file = form1data['url_question']
#Get number of sections
sections = int(form1data['section'])
#Error variables
url_errors = []
file_errors = []
section_errors = []
pdf_errors = []
status_errors = []
if form.validate_on_submit():
#Loops through inputs of form
for input in request.form:
#checks if inputs are empty and adds ids to the corresponding error list
if request.form[input] == '':
check = input.split('_')
if check[0] == 'url':
url_errors.append(int(check[1]))
elif check[0] == 'section':
section_errors.append(int(check[1]))
elif check[0] == 'file':
file_errors.append(int(check[1]))
else:
if url_or_file == 'Yes':
if 'url' in input:
#checks if url is pdf link
url = request.form[input]
try:
parsed_url = urlparse(url)
#checks if the user input has a schema
if not parsed_url.scheme:
url = "http://" + url
proxies = {
"http":
"http://cscisa.csc.nycnet:8080/array.dll?Get.Routing.Script",
"https":
"http://cscisa.csc.nycnet:8080/array.dll?Get.Routing.Script"
}
print "requesting: " + url
r = requests.get(url_fix(url),
proxies=proxies,
timeout=1)
if r.status_code == 404:
status_errors.append(int(input.split('_')[1]))
if r.headers['content-type'] != 'application/pdf':
pdf_errors.append(int(input.split('_')[1]))
#if requesting the website fails; do regular expression checking
except:
match = re.search('[\w%+\/-].pdf',
request.form[input])
if not match:
pdf_errors.append(int(input.split('_')[1]))
#loops through the files inputted
for file_ in request.files:
file_id = file_.split('_')[1]
#no files inputted add to files errors list
if request.files[file_].filename == '':
file_errors.append(int(file_id))
#check is the files one of the allowed files ext
if not allowed_file(request.files[file_].filename):
pdf_errors.append(int(file_id))
#if errors respond with errors
if pdf_errors or section_errors or url_errors or status_errors or file_errors:
pass
else:
#Urls processing
if url_or_file == 'Yes':
if sections == 1:
url = request.form.get('url_1')
parsed_url = urlparse(url)
#check schema
if not parsed_url.scheme:
url = url_fix("http://" + url)
download_url = URL(url)
date_created = datetime.date(int(form1data['year']),
int(form1data['month']),
int(form1data['day']))
doc = Document(title=form1data['title'],
type=form1data['type'],
description=form1data['description'],
dateCreated=date_created,
agency=session['agency'],
category=form1data['category'],
doc_url=url)
db.session.add(doc)
#add document meta data to datebase
db.session.commit()
#get max common id
did = db.session.query(func.max(Document.id)).scalar()
doc = Document.query.get(did)
filename = str(did) + '_' + form1data['title']
doc.filename = filename
#download file into upload folder
try:
f = open(
os.path.join(app.config['UPLOAD_FOLDER'],
filename + ".pdf"), 'wb')
if urlparse(url).scheme == "https://":
f.write(
download_url.download(
cached=False,
proxy=
("http://cscisa.csc.nycnet:8080/array.dll?Get.Routing.Script",
'https')))
else:
f.write(
download_url.download(
cached=False,
proxy=
("http://cscisa.csc.nycnet:8080/array.dll?Get.Routing.Script",
'http')))
f.close()
#hardcopy set to yes if downloaded
doc.hardcopy = "yes"
doc.path = os.path.join(app.config['DOC_PATH'],
filename)
#NOTE: Script must be written for documents that have hardcopy set to no; to download file
except:
pass
sub = Submit(did=did, uid=session['uid'])
db.session.add(sub)
db.session.commit()
#if more that one sections do samething above for each section
elif sections > 1:
#gets the common id to be inserted by querying the max common id + 1
common_id = db.session.query(func.max(
Document.common_id)).scalar()
if not common_id:
common_id = 1
else:
common_id = common_id + 1
for doc in range(1, (sections + 1)):
url = 'url_' + str(doc)
url = request.form.get(url)
parsed_url = urlparse(url)
if not parsed_url.scheme:
url = url_fix("http://" + url)
download_url = URL(url)
sectionid = 'section_' + str(doc)
section = request.form.get(sectionid)
date_created = datetime.date(int(form1data['year']),
int(form1data['month']),
int(form1data['day']))
doc = Document(title=form1data['title'],
type=form1data['type'],
description=form1data['description'],
dateCreated=date_created,
agency=session['agency'],
category=form1data['category'],
doc_url=url,
common_id=common_id,
section_id=doc)
db.session.add(doc)
db.session.commit()
did = db.session.query(func.max(Document.id)).scalar()
doc = Document.query.get(did)
filename = str(did) + '_' + form1data['title']
doc.filename = filename
try:
f = open(
os.path.join(app.config['UPLOAD_FOLDER'],
filename + ".pdf"), 'wb')
if urlparse(url).scheme == "https://":
f.write(
download_url.download(
cached=False,
proxy=
("http://cscisa.csc.nycnet:8080/array.dll?Get.Routing.Script",
'https')))
else:
f.write(
download_url.download(
cached=False,
proxy=
("http://cscisa.csc.nycnet:8080/array.dll?Get.Routing.Script",
'http')))
f.close()
doc.hardcopy = "yes"
doc.path = os.path.join(app.config['DOC_PATH'],
filename)
except:
pass
sub = Submit(did=did, uid=session['uid'])
sec = Section(did=did, section=section)
db.session.add(sec)
db.session.add(sub)
db.session.commit()
#if the user clicked files
elif url_or_file == 'No':
if sections == 1:
file = request.files['file_1']
if file:
date_created = datetime.date(int(form1data['year']),
int(form1data['month']),
int(form1data['day']))
doc = Document(title=form1data['title'],
type=form1data['type'],
description=form1data['description'],
dateCreated=date_created,
agency=session['agency'],
category=form1data['category'])
db.session.add(doc)
db.session.commit()
did = db.session.query(func.max(Document.id)).scalar()
doc = Document.query.get(did)
filename = str(did) + '_' + doc.title + ".pdf"
file.save(
os.path.join(app.config['UPLOAD_FOLDER'],
filename))
doc.path = os.path.join(app.config['DOC_PATH'],
filename)
doc.filename = filename
doc.hardcopy = 'yes'
sub = Submit(did=did, uid=session['uid'])
db.session.add(sub)
db.session.commit()
elif sections > 1:
for doc in range(1, (sections + 1)):
fileid = "file_" + str(doc)
file = request.files[fileid]
if file:
date_created = datetime.date(
int(form1data['year']),
int(form1data['month']), int(form1data['day']))
doc = Document(
title=form1data['title'],
type=form1data['type'],
description=form1data['description'],
dateCreated=date_created,
agency=session['agency'],
category=form1data['category'])
sectionid = 'section_' + str(doc)
section = request.form.get(sectionid)
db.session.add(doc)
db.session.commit()
did = db.session.query(func.max(
Document.id)).scalar()
doc = Document.query.get(did)
filename = str(did) + '_' + doc.title + ".pdf"
file.save(
os.path.join(app.config['UPLOAD_FOLDER'],
filename))
doc.filename = filename
doc.hardcopy = 'yes'
doc.path = os.path.join(app.config['DOC_PATH'],
filename)
sub = Submit(did=did, uid=session['uid'])
sec = Section(did=did, section=section)
db.session.add(sub)
db.session.add(sec)
db.session.commit()
#set session variable confirm to be true so that comfirmation page is allowed through
session['confirm'] = True
return redirect(url_for('confirmation'))
return render_template('submit2.html',
back=session['back'],
form=form,
submit2form=request.form,
submit2files=request.files,
sections=int(sections),
url_or_file=url_or_file,
url_errors=url_errors,
section_errors=section_errors,
status_errors=status_errors,
pdf_errors=pdf_errors,
file_errors=file_errors)
def test_course_endpoints(self):
""" Create a course, add some sections, delete some things, and rename some things """
########################################################
# Set up a user and a course
user = rand.user()
course = Course(name='US History')
section1 = Section(name='Hour 1')
section2 = Section(name='Hour 2')
course.sections = [section1, section2]
user.courses.append(course)
db.session.add_all([user, course, section1, section2])
db.session.commit()
token_request_json = {'email': user.email}
########################################################
# Verify that we have a single course for this user
course_list_response = self.client.get(
'/api/course/',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
course_list_data = json.loads(course_list_response.data.decode())
self.assertEqual(len(course_list_data['courses']), 1)
self.assertEqual(course_list_data['courses'][0]['name'], 'US History')
course_id = course_list_data['courses'][0]['id']
########################################################
# Create a new course and verify that we now have two
new_course_json = {
'name': 'World History',
'sections': ['Hour 5', 'Hour 6', 'Hour 7', 'Study Hall']
}
course_add_response = self.client.post(
'/api/course/add',
headers={'Authorization': 'Bearer {}'.format(jwt_token)},
content_type='application/json',
data=json.dumps(new_course_json))
self.assertEqual(course_add_response.status_code, HTTPStatus.OK)
course_add_response_json = json.loads(
course_add_response.data.decode())['course']
new_course_id = course_add_response_json['id']
self.assertEqual(len(course_add_response_json['sections']), 4)
self.assertEqual(course_add_response_json['sections'][1]['name'],
'Hour 6')
course_list_response = self.client.get(
'/api/course/',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
course_list_data = json.loads(course_list_response.data.decode())
self.assertEqual(len(course_list_data['courses']), 2)
########################################################
# Update the course we created
update_course_json = {'name': 'Early World History'}
course_update_response = self.client.post(
'/api/course/update/{course_id}'.format(course_id=new_course_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)},
content_type='application/json',
data=json.dumps(update_course_json))
self.assertEqual(course_update_response.status_code, HTTPStatus.OK)
get_updated_course_response = self.client.get(
'/api/course/{course_id}'.format(course_id=new_course_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
get_updated_course_response_json = json.loads(
get_updated_course_response.data.decode())['course']
self.assertEqual(get_updated_course_response.status_code, 200)
self.assertEqual(get_updated_course_response_json['name'],
'Early World History')
self.assertEqual(len(get_updated_course_response_json['sections']), 4)
########################################################
# Add a new section to our newly created course
new_section_json = {'name': 'New Section foo'}
add_new_section_response = self.client.post(
'/api/course/{course_id}/section/add'.format(
course_id=new_course_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)},
content_type='application/json',
data=json.dumps(new_section_json))
self.assertEqual(add_new_section_response.status_code, HTTPStatus.OK)
new_section_id = json.loads(
add_new_section_response.data.decode())['section']['id']
get_updated_course_response = self.client.get(
'/api/course/{course_id}'.format(course_id=new_course_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
get_updated_course_response_json = json.loads(
get_updated_course_response.data.decode())['course']
self.assertEqual(len(get_updated_course_response_json['sections']), 5)
self.assertIn('New Section foo', [
section['name']
for section in get_updated_course_response_json['sections']
])
########################################################
# Update the section we created
update_section_json = {'name': 'Updated section name'}
update_section_response = self.client.post(
'/api/course/{course_id}/section/{section_id}/update'.format(
course_id=new_course_id, section_id=new_section_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)},
content_type='application/json',
data=json.dumps(update_section_json))
self.assertEqual(add_new_section_response.status_code, HTTPStatus.OK)
self.assertEqual(
json.loads(update_section_response.data.decode())['section']['id'],
new_section_id)
get_updated_course_response = self.client.get(
'/api/course/{course_id}'.format(course_id=new_course_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
get_updated_course_response_json = json.loads(
get_updated_course_response.data.decode())['course']
self.assertIn('Updated section name', [
section['name']
for section in get_updated_course_response_json['sections']
])
########################################################
# Delete the section we created
delete_section_response = self.client.delete(
'/api/course/{course_id}/section/{section_id}'.format(
course_id=new_course_id, section_id=new_section_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
self.assertEqual(delete_section_response.status_code, HTTPStatus.OK)
get_updated_course_response = self.client.get(
'/api/course/{course_id}'.format(course_id=new_course_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
get_updated_course_response_json = json.loads(
get_updated_course_response.data.decode())['course']
self.assertEqual(len(get_updated_course_response_json['sections']), 4)
self.assertNotIn('Updated section name', [
section['name']
for section in get_updated_course_response_json['sections']
])
########################################################
# Delete our new course, assert we're back to one course
delete_course_response = self.client.delete(
'/api/course/{course_id}'.format(course_id=new_course_id),
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
self.assertEqual(delete_course_response.status_code, HTTPStatus.OK)
course_list_response = self.client.get(
'/api/course/',
headers={'Authorization': 'Bearer {}'.format(jwt_token)})
course_list_data = json.loads(course_list_response.data.decode())
self.assertEqual(len(course_list_data['courses']), 1)
self.assertNotIn(
'Early World History',
[course['name'] for course in course_list_data['courses']])
hour = int(hour_str[:-2])
if hour_str[-2:] == "PM" and hour != 12:
hour += 12
start_time = pst.localize(
datetime(year=2021, month=1, day=day, hour=hour, minute=10))
end_time = start_time + timedelta(minutes=50)
if email not in users:
users[email] = User(email=email, name=name, is_staff=True)
section = Section(
id=group,
start_time=start_time.timestamp(),
end_time=end_time.timestamp(),
capacity=9,
staff=users[email],
)
if is_npe:
section.tags = ["NPE"]
lookup[group] = section
db.session.add(section)
for row in student_reader[1:]:
name, email, time, group, npe = row
lookup[group].students.append(
User(email=email, name=name, is_staff=False))
print([len(sections) for sections in sections_by_npe])
for row in reader:
if not row:
break
if row[0] != "FALSE":
continue
assert len(row) == 11
npe = row[-2] == "TRUE"
if row[-1] == "TRUE":
print("Reassigning empty section to tutor: {}, NPE: {}".format(row[1], npe))
section = sections_by_npe[npe].pop()
section.staff = get_user(row[2], row[1])
else:
print("Creating new section with tutor: {}, NPE: {}".format(row[1], npe))
section = Section(
start_time=start_time.timestamp(),
end_time=end_time.timestamp(),
capacity=5,
staff=get_user(row[2], row[1]),
)
if npe:
section.tags = ["NPE"]
db.session.add(section)
db.session.commit()
