def course_ratings_create(username: str):
schema = Schema({
"collegename": And(str, len, error="No College Name"),
"coursename": And(str, len, error="No Course Name"),
"coursenumber": And(str, len, error="No Course Number"),
"courserating": And(str, len, error="No Course Rating"),
"coursepositive": And(str, len, error="No Course Positive"),
"coursenegative": And(str, len, error="No Course Negative"),
"username": And(str, len, error="No Username")
})
form = {
"collegename": request.json.get("collegename"),
"coursename": request.json.get("coursename"),
"coursenumber": request.json.get("coursenumber"),
"courserating": request.json.get("courserating"),
"coursepositive": request.json.get("coursepositive"),
"coursenegative": request.json.get("coursenegative"),
"username": request.json.get("username")
}
print(request.json)
print(form)
validated = schema.validate(form)
#print(validated)
#user = User.objects(username=username).first()
post = Course(collegename=validated["collegename"],
coursename=validated["coursename"],
coursenumber=validated['coursenumber'],
courserating=validated["courserating"],
coursepositive=validated["coursepositive"],
coursenegative=validated["coursenegative"],
username=validated["username"]).save()
print(post)
return jsonify(post.to_public_json())
def create_courses():
body = request.get_json()
crs_title = body.get('title')
crs_code = body.get('code')
crs_desc = body.get('desc')
crs_book = body.get('book')
crs_lec = int(body.get('lec'))
crs_room = int(body.get('room'))
error = False
try:
# instantiate course object
crs = Course(crs_code, crs_title, crs_desc, crs_book, crs_lec,
crs_room)
crs.insert()
courses = Course.query.order_by(Course.crs_id).all()
courses_list = [course.format for course in courses]
except Exception as e:
db.session.rollback()
error = True
print(sys.exc_info())
finally:
db.session.close()
if error:
abort(422)
else:
return redirect('/courses')
def setup(teacher):
title = curses.wrapper(get_input, 'Enter your course title: ')
Course.insert({
Course.title: title,
Course.teacher: teacher,
}).execute()
curses.wrapper(show_message, 'your course request successfully saved!')
def _course_exists(request):
form = CourseInitialForm(request.POST, request.FILES)
if form.is_valid():
section_number = ""
if request.user.get_profile().school.title == "James Madison University":
section_number = request.POST['course_id'].zfill(4)
else:
section_number = request.POST['course_id']
try:
course = Course.objects.get(
number__iexact=request.POST['course_number'],
course_id__iexact=section_number,
institution__iexact=request.user.get_profile().school.title)
return (True, course)
except Course.DoesNotExist:
wall = ConvoWall(wall_type=3)
wall.save()
course = Course(
wall=wall,
number=request.POST['course_number'],
course_id=section_number,
institution=request.user.get_profile().school.title)
course.save()
return (False, course)
return (False, None)
def create_course():
try:
print('创建课程'.center(60, '-'))
school_list = School.get_all_obj_list()
for k, obj in enumerate(school_list):
print(k, obj, obj.addr)
sid = int(input('请选择学校:'))
school_obj = school_list[sid]
name = input('请输入课程名:').strip()
price = input('请输入课程价格:').strip()
period = input('请输入课程周期:').strip()
course_name_list = [(obj.name, obj.school_nid.uuid)
for obj in Course.get_all_obj_list()]
if (name, school_obj.nid.uuid) in course_name_list:
raise Exception('\033[43;1m课程[%s] 已存在，不可重复创建\033[0m' % name)
obj = Course(name, price, period, school_obj.nid)
obj.save()
status = True
error = ''
data = '\033[33;1m课程[%s] 价格[%s] 周期[%s] 创建成功\033[0m' % (
obj.name, obj.price, obj.period)
except Exception as e:
status = False
error = str(e)
data = ''
return {'status': status, 'error': error, 'data': data}
def parse_schedule():
html = open("switcher/schedule.txt")
counter = 0
department = ""
for line in html:
print counter
counter += 1
if re.findall(r'\S+', line) == []:
continue
x = re.findall('([A-Z]+[\s,/&]*?[A-Z]+)\s\s+([0-9A-Z]+)\s+([\s\S]+[\S])', line)
if x == []:
department = line.strip()
#print department
#"""
d = Department()
d.init(department)
d.save()
#"""
else:
#print x
code = x[0][0] + "." + x[0][1] + ".Spring.2014"
#"""
c = Course()
c.init(code, d)
c.save()
def setUp(self):
self.testbed = testbed.Testbed()
self.testbed.activate()
self.testbed.init_datastore_v3_stub()
# should all return None, because this is simply creating data and is all meant to be correct
self.assertIsNone(User.register(None, '*****@*****.**', 'pwd', 'pwd', 'teacher', 't'))
self.assertIsNone(User.register(None, '*****@*****.**', 'pwd', 'pwd', 'teachertwo', 'ttwo'))
self.assertIsNone(User.register(None, '*****@*****.**', 'pwd', 'pwd', 'student', 's'))
self.teacher = User.all().filter('email =', '*****@*****.**').get()
self.teacher2 = User.all().filter('email =', '*****@*****.**').get()
self.student = User.all().filter('email =', '*****@*****.**' ).get()
self.assertIsNotNone(self.teacher)
self.assertIsNone(self.teacher.make_teacher())
self.assertIsNotNone(self.teacher2)
self.assertIsNone(self.teacher2.make_teacher())
self.assertIsNone(Course.create(self.teacher, 'public', ''))
self.public = Course.all().filter('name =', 'Public').get()
self.assertIsNotNone(self.public)
self.assertIsNone(Course.create(self.teacher, 'private', 'on'))
self.private = Course.all().filter('name =', 'Private').get()
self.assertIsNotNone(self.private)
def get(self):
from models import *
from google.appengine.ext import db
db.delete(Course.all())
db.delete(Offerings.all())
import re
rx_department = re.compile(r'[A-Z]+')
import csv
reader = csv.DictReader(open('resources/dump.csv'))
try:
for course in reader:
name = course['name']
number = course['number']
description = course['description'][:500]
match = rx_department.match(number)
department = number
if match:
department = match.group(0)
entry = Course(name=name, number=number, description=description, department=department)
entry.put()
for item in ['winter', 'spring', 'fall', 'summer']:
if 1 < len(course[item]):
offering = Offerings(course=entry, offered=item)
offering.put()
except KeyError, e:
pass
def create_new_course(payload):
courses = []
result = {
"success": True,
}
try:
body = json.loads(request.data)
name = body['name']
description = body['description']
price = body['price']
new_course = Course(name=name,
description=description,
price=price)
new_course.insert()
courses.append(new_course.format())
except Exception as e:
print(e)
abort(500)
result['courses'] = courses
return jsonify(result)
def insert_course(dept, num, text):
""" Regexes for extracting class properties; results go into capture group 1 """
# Course Title
m = re.search("[\d\w]{5} - ([\w ]*)", text)
title = m.group(1) if m else "nomatch"
# Course Description
m = re.search("\.\s(.*)\sTypically",text)
des = m.group(1) if m else "nomatch"
# Credit hours aren't fixed for every course
# Credit Hours: 2.00
# Credit Hours: 2.00 or 3.00.
# Credit Hours: 1.00 to 18.00.
m = re.search("Credit Hours: (\d+\.\d+)",text, flags=re.IGNORECASE)
m = re.search("(\d+\.\d+)(.*?)Credit hours",text, flags=re.IGNORECASE) if not m else m
cr = m.group(1) if m else "-1"
# Semesters Offered
m = re.search("Typically offered (.*?)\.", text)
sem = m.group(1).split() if m else ["nomatch"]
# Course Type: Lecture, Recitation, Lab, Seminar, etc.
m = re.search("Schedule Types:\s((?:[\w ]+)(?:,[\w ]+)*) \s+", text)
form = m.group(1).split(", ") if m else ["nomatch"]
# Learning objectives will not necessarily follow campuses
m = re.search("campuses:(\s+([\w\s])+\n)", text)
campus = m.group(1).strip().split("\n\n") if m else ["nomatch"]
campus = [camp.strip() for camp in campus]
# prereq regex and decomosition of prereqs into lists of AND conditions (works for most classes, not 477 and similar)
# re.DOTALL matches all characters, including "\n"
idx = text.find("campuses:")
m = re.search("Prerequisites:(.*)",text[idx:],flags=re.DOTALL)
if m:
allReqs = []
prereqText = m.group(1).strip()
prereqText = prereqText.encode('ascii', 'ignore')
for i in PrereqParser.parseprereq(prereqText):
reqArr = []
for j in i.split():
if j.find("-C") != -1:
j = j.replace("-C","")
reqArr.append(Requisite(course=j,reqType=False))
else:
reqArr.append(Requisite(course=j,reqType=True))
allReqs.append(RequisiteList(courses=reqArr))
else:
allReqs = []
# create course entity
course = Course(number=num, title=title, department=dept, form=form,
description=des, credits=float(cr), semesters=sem,
campuses=campus,requisites=allReqs, id=dept + num)
# store course
course.put()
def test_course_insert(self):
print "in test_course_insert"
setup(self)
self.assertEqual(Course.objects.count(), 2)
course3 = Course(teacher=Teacher.objects.get(pk=1), name="Grad3", position=3)
course3.save()
self.assertEqual(Course.objects.count(), 3)
def create_data1(self):
obj = Course(title='英语')
obj.student_list = [
Student(name='小杰'),
Student(name='小工'),
]
session.add(obj)
session.commit()
def test_create_course(self):
c = Course(title = 'Some Course',
start_time='09:00',
slots=20)
c.save()
self.assertQuerysetEqual(Course.objects.all(),
['<Course: Some Course>'])
def create(self, request):
serializer = self.serializer_class(data=request.data)
if serializer.is_valid():
course = Course(**serializer.data)
course.owner = request.user
course.save()
return Response(status=201)
return Response(serializer.errors, status=400)
def addCourses():
# Add some additional Courses
db_session.add(Course(id='CS F241', name='Microprocessors and Interfacing'))
db_session.add(Course(id='MATH F211', name='Mathematics III'))
db_session.add(Course(id='ECON F211', name='Principle Of Economics'))
db_session.add(Course(id='CS F215', name='Digital Design'))
db_session.commit()
print "Added Courses"
def test_code_uniqueness(self):
Course.create_one(code=course_data[0]['code'],
title='test',
description='test')
with pytest.raises(IntegrityError):
db.session.commit()
db.session.rollback()
def test_day(self):
course = Course(
slug='day-course',
days=[
('Mondays', '7:00', '8:00pm'), ('Tuesdays', '3:00', '4:00pm')
]
)
self.assertEqual(course.day('mondays'), course.days[0])
self.assertEqual(course.day('Tuesdays'), course.days[1])
self.assertRaises(KeyError, lambda: course.day('Saturdays'))
def test_update(self):
Course.create_one(**course_data[1])
db.session.commit()
Course.get_one(code=course_data[1]['code']).update(
description='Updated description.')
db.session.commit()
assert Course.get_one(
code=course_data[1]['code']).description == 'Updated description.'
def all(self):
statement = f'SELECT * from {self.tablename}'
self.cursor.execute(statement)
result = []
for item in self.cursor.fetchall():
id, name, category = item
course = Course(name, category)
course.id = id
result.append(course)
return result
def populate(line):
overall = line.split('#')
forCourses = overall[0].strip().split(',')
y = [y.strip() for y in overall[1].strip().split('$')]
c = Course(course_name=forCourses[0], course_ID=forCourses[1], course_acronym=forCourses[2], course_credits=int(forCourses[3]))
c.save()
c = Course.objects.get(pk=c.pk)
for x in y:
temp = [e.strip() for e in x.split(',')]
c.offered_set.create(class_day=temp[0],start_time=str(1+TIME_CHOICES.index(temp[1])),end_time=str(1+TIME_CHOICES.index(temp[2])))
def upload_courses(prid, filename):
book = xlrd.open_workbook(filename)
coursesNum = book.nsheets
coursesNames = book.sheet_names()
for i in range(coursesNum):
thisSheet = book.sheet_by_index(i)
#print thisSheet.col_values(0)
cs = thisSheet.col_values(0)
course_name = coursesNames[i]
course = Course(name=course_name)
course.save()
pr = Project.objects.get(id=prid)
print pr.name
course.project = pr
course.save()
for st in cs:
st = Student(stdnom=str(int(st)))
st.save()
course.students.add(st)
course.save()
return projects(request)
def addCourse(request):
# if request.user.type != "Admin":
# return HttpResponse("You need to be Admin to access this content")
# else:
if request.method == "GET":
return render(request, 'app/addCourse.html')
else:
courseCode = request.POST['ccode']
course = Course(courseCode=courseCode, studentList={'studentList': []})
course.save()
return HttpResponse("Course Added")
def add_course(permission):
body = request.get_json()
try:
course = Course(body['course_name'], body['domain_id'],
body['platform_id'], body['website'],
body['price_per_month'], body['duration_months'])
course.insert()
return jsonify({'success': True, 'course_id': course.id})
except:
abort(422)
def addcourses(self):
fields = ['name', 'short_desc', 'dept', 'number', 'level']
parent = Key(Source, 'Udacity')
for course in cdata:
opt = dict(zip(fields, course))
opt['source'] = parent
kn = self.centid('Udacity', opt['dept'], opt['number'])
opt['number'] = int(opt['number'])
Course.get_or_insert(kn, **opt)
def create_course(request, name, description, price, discount, init_date, end_date):
s = Session.objects.get(session_key=request.session["auth_token"])
user = User.objects.get(login=s.get_decoded()['login'])
if user.user_type != 'Creator':
return HttpResponseBadRequest('User is not Creator')
init_date_parsed = dateutil.parser.parse(init_date)
end_date_parsed = dateutil.parser.parse(end_date)
course = Course(creator=user, name=name, description=description, price=price, discount=discount,
init_date=init_date_parsed, end_date=end_date_parsed)
course.save()
return HttpResponse('Course created successful')
def test_add(self):
course = Course.create_one(**course_data[0])
db.session.commit()
course = Course.get_one(guid=course.guid)
assert course is not None
assert course.code == course_data[0]['code']
assert course.title == course_data[0]['title']
assert course.description == course_data[0]['description']
assert course.takeaways == course_data[0]['takeaways']
assert course.tags == course_data[0]['tags']
assert course.outlines == course_data[0]['outlines']
def list_courses_data(owner, list_of_courses):
my_list = []
for course in list_of_courses:
my_list.append(
{'paper_name': course.name, 'paper_code':
Course.generate_course_token(course.id,EXPIRY_INTERVAL * 2),
'duration': course.duration_in_minutes, 'instructor': course.lecturer_in_charge,
'departments': jsonify_departments(course.departments), 'randomize': course.randomize_questions,
'owner': owner.username, 'reply_to': url_for('auth.post_secure_sesd_route', _external=True),
'url': url_for('auth.get_paper_route', url=coursify(course.id, course.quiz_filename),
_external=True)})
return my_list
def seed_data():
ron_key = Student(student_id=423491377, first_name ="Ron", last_name = "Weasley").put()
harry_key = Student (student_id=423491782, first_name ="Harry", last_name = "Potter").put()
hermione_key = Student(student_id=423491249, first_name="Hermione", last_name="Granger").put()
malfoy_key = Student(student_id=42391043, first_name="Draco", last_name="Malfoy").put()
crabbe_key = Student(student_id=42391122, first_name="Vincent", last_name="Crabbe").put()
goyle_key = Student(student_id=42391063, first_name="Gregory", last_name="Goyle").put()
ron_wand=Wand(length = 14.0, material = "willow", core="unicorn", owner=ron_key)
harry_wand=Wand(length = 11.0, material = "holly", core="phoenix feather", owner=harry_key)
hermione_wand = Wand(length=10.75, material="vinewood", core="dragon heartstring", owner=hermione_key)
ron_wand.put()
harry_wand.put()
hermione_wand.put()
gryff = House(name="Gryffindor", mascot="Lion", students=[ron_key, harry_key, hermione_key])
snakes = House(name="Slytherin", mascot="Snake", students=[malfoy_key, crabbe_key, goyle_key])
hufflepuff = House(name="Hufflepuff", mascot="Badger", students=[])
ravenclaw = House(name="Ravenclaw", mascot="Eagle", students=[])
gryff.put()
snakes.put()
hufflepuff.put()
ravenclaw.put()
potions = Course(name="Potions", location="dungeon")
dada = Course(name="Defense Against the Dark Arts", location="3C")
transfiguration = Course(name="Transfiguration", location="Class 34")
potions_key = potions.put()
dada_key = dada.put()
transfiguration_key = transfiguration.put()
#dada
Enrollment(student=ron_key, course=dada_key).put()
Enrollment(student=harry_key, course=dada_key).put()
Enrollment(student=hermione_key, course=dada_key).put()
#potions
Enrollment(student=hermione_key, course=potions_key).put()
Enrollment(student=ron_key, course=potions_key).put()
Enrollment(student=malfoy_key, course=potions_key).put()
Enrollment(student=crabbe_key, course=potions_key).put()
Enrollment(student=goyle_key, course=potions_key).put()
#tranfirguration
Enrollment(student=harry_key, course=transfiguration_key).put()
Enrollment(student=hermione_key, course=transfiguration_key).put()
Enrollment(student=crabbe_key, course=transfiguration_key).put()
Enrollment(student=goyle_key, course=transfiguration_key).put()
snape = Teacher(name="Severus Snape", years_experience=5, classes_taught=[potions_key])
snape.put()
moody = Teacher(name="Alastor Moody", years_experience=1, classes_taught=[dada_key])
moody.put()
mcgonagall = Teacher(name="Minerva McGonagall", years_experience=12, classes_taught=[transfiguration_key])
mcgonagall.put()
def post(self):
fields = ['source', 'number', 'dept', 'name', 'level', 'description']
p = self.get_params_dict(fields)
s = Source.query()
c = Course.query()
errors, p, kn = self.prepare_course(p, fields)
context = {'errors': errors, 'sources': s, 'courses': c}
if not errors:
Course.get_or_insert(kn, **p)
self.redirect('/')
else:
self.render('classes.html', context)
def setup():
print("Setup")
Base.metadata.drop_all(bind=db.engine)
Base.metadata.create_all(bind=db.engine)
db.session.add(User('*****@*****.**', 'password123', 's'))
db.session.add(User('*****@*****.**', 'password123', 'p'))
db.session.add(User('*****@*****.**', 'password123', 'a'))
db.session.add(
Course('CS2043', 'Software Engineering 1', 'Dr. Jong-Kyou Kim', 3))
db.session.add(
Course('CS2263', 'Systems Software Development', 'Dr. Jeffrey McNally',
6))
db.session.add(Course('CS1083', 'Java 2', 'Dr. Josee Tasse', 9))
db.session.commit()
def create_sample_courses():
for y in range(2009,2012):
create_semester('Fall', y, 9, 1, 12, 31)
create_semester('Spring', y, 1, 1, 5, 30)
semesters = Semester.objects.all()
for co,nm in [("CS 101", "Fundamentals of Computer Science"),
("CS 102", "Programming I"),
("CS 117", "Programming II"),
("CS 150", "Operating Systems"),
("CS 164", "Software Engineering"),
("CS 130", "Algorithms & Data Structures")]:
for sem in random.sample(semesters, 3):
tag = co.replace(' ', '').lower() + sem.tag
grp = Group(name=tag)
grp.save()
key = '%x' % random.getrandbits(24)
c = Course(tag=tag, name=nm, code=co, semester=sem,
group=grp, key=key,
is_active=_flip())
c.save()
us = random.sample(User.objects.all(), random.randrange(4,8))
num_instructors = random.choice([1,2])
instrs = us[:num_instructors]
studs = us[num_instructors:]
for u in us:
e = Enrollment(course=c, user=u,
kind = 'I' if u in instrs
else random.choice(['A', 'G']),
notify_on_commit = _flip(),
notify_new_grades = _flip())
e.save()
ln = CourseLink(course=c, kind='H',
url='http://liucs.net/%s/' % tag)
ln.save()
if _flip():
ln = CourseLink(course=c, kind='T',
url='http://amazon.com/%s' % nm)
ln.save()
if _flip():
fmt = random.choice(['http://liucs.net/svn/%s/',
'http://github.com/league/%s'])
ln = CourseLink(course=c, kind='R', url=fmt % tag)
ln.save()
def save(self, commit=True, created_by=None):
name = self.cleaned_data["name"]
duration = self.cleaned_data["duration"]
description = self.cleaned_data["description"]
value = self.cleaned_data["value"]
status = self.cleaned_data["status"]
course = Course(name=name,
duration=duration,
description=description,
value=value,
status=status,
created_updated_by=created_by)
if commit and created_by is not None:
course.save()
return course
def populate(line):
overall = line.split('#')
forCourses = overall[0].strip().split(',')
y = [y.strip() for y in overall[1].strip().split('$')]
c = Course(course_name=forCourses[0],
course_ID=forCourses[1],
course_acronym=forCourses[2],
course_credits=int(forCourses[3]))
c.save()
c = Course.objects.get(pk=c.pk)
for x in y:
temp = [e.strip() for e in x.split(',')]
c.offered_set.create(class_day=temp[0],
start_time=str(1 + TIME_CHOICES.index(temp[1])),
end_time=str(1 + TIME_CHOICES.index(temp[2])))
def courses():
if request.method == 'GET':
year = request.args.get('year')
courses = query_factory.get_courses_by_year(year)
courses_list = []
for course in courses:
course_dict = {
'name': course[0],
'code': course[1],
'year': course[2]
}
staff_list = query_factory.get_course_staff(course[1])
staff_members = []
for staff_member in staff_list:
staff_members.append(staff_member[0])
course_dict['staff'] = staff_members
courses_list.append(course_dict)
return jsonify(courses_list)
elif request.method == 'PUT':
data = request.get_json()
old_course_code = data.get('code')
new_course_code = data.get('newCourse').get('code')
new_course_name = data.get('newCourse').get('name')
new_course_year = data.get('newCourse').get('year')
new_course = Course(name=new_course_name,
code=new_course_code,
year=new_course_year)
(is_successful,
message) = query_factory.edit_course(old_course_code, new_course)
response = {'is_successful': is_successful, 'message': message}
return jsonify(response)
elif request.method == 'POST':
data = request.get_json()
new_course_code = data.get('newCourse').get('code')
new_course_name = data.get('newCourse').get('name')
new_course_year = data.get('newCourse').get('year')
new_course = Course(name=new_course_name,
code=new_course_code,
year=new_course_year)
(is_successful, message) = query_factory.add_course(new_course)
response = {'is_successful': is_successful, 'message': message}
return jsonify(response)
elif request.method == 'DELETE':
deleted_course_code = request.args.get('deletedCourseCode')
(is_successful,
message) = query_factory.delete_course(deleted_course_code)
response = {'is_successful': is_successful, 'message': message}
return jsonify(response)
def updateSummary():
logging.info("UPDATING SUMMARY")
query = Summary.all()
db.delete(query)
courses = Course.all()
items = []
for course in courses:
item = {}
item['name'] = course.name
item['id'] = course.cid
item['hasSept'] = course.hasSeptemberResults
item['hasFebr'] = course.hasFebruaryResults
item['hasJune'] = course.hasJuneResults
item['recent'] = course.nTimesUpdated
item['addedJune'] = str(course.added_june)
item['addedSept'] = str(course.added_sept)
item['addedFebr'] = str(course.added_febr)
items.append(item)
summary = Summary()
summary.courses = simplejson.dumps(items)
summary.put()
logging.info("FINISHED UPDATING SUMMARY")
def list_assignments(self):
course = Course(self.api_client.client, self.args.course)
labs = [hw["name"] for hw in Lab.list(course)]
if len(labs) == 0:
print("Course has no labs.")
else:
print_list(labs)
def myget(self, course_id):
course = Course.get_by_id(int(course_id))
if course is None:
return self.error(404)
if not self.user.has_permission(course):
self.redirect(LIST_COURSES_URL)
return {'course': course}
def browse_one_course(request, course_query, school):
""" View for viewing notes from a fuzzy course search
:course_query: unicode url match, to be type parsed
"""
# TODO: combine this function with `b_school_course`
response = nav_helper(request)
try:
course_query = int(course_query)
except ValueError:
# cant be cast as an int, so we will search for it as a string
pass
course, files = Course.get_notes(course_query, school)
response['course'], response['files'] = course, files
# get the users who are members of the course
response['profiles'] = course.userprofile_set.all()
# get the karma events associated with the course
response['events'] = course.reputationevent_set.order_by('-timestamp').all() # FIXME: possibly order-by
response['viewed_files'] = request.user.get_profile().files.all()
# FIXME: I don't like this logic one bit, either annotate the db query or fix the schema to NEVER do this
response['thanked_files'] = []
response['flagged_files'] = []
for file in files:
_vote = file.votes.filter(user=request.user)
if _vote.exists():
if _vote[0].up: # assuming only one vote result
response['thanked_files'].append(file.id)
else:
response['flagged_files'].append(file.id)
return render(request, 'browse_one_course.html', response)
def put(self, cid):
"""
用于修改cid对应的数据行, 表单只需填写需要修改的数据项即可
"""
parser = reqparse.RequestParser()
parser.add_argument('cid', type=str)
parser.add_argument('cname', type=str)
parser.add_argument('chours', type=int)
parser.add_argument('credit', type=float)
parser.add_argument('precid', type=str)
args = parser.parse_args()
ModifyCourse = Course.get({'cid': cid})
#判断是否存在数据
if ModifyCourse is None:
return {'error' : "has no course data with cid: %s for modify(put), please send post request to create first" % cid}, 404
#若表单给出cid,此cid与url对应不同报错
if args['cid'] is not None and args['cid'] != cid:
return {'error' : "url's(put) cid(%s) is not equal to form cid(%s)" % (cid, args['cid'])},400
for key, value in args.iteritems():
if value is not None:
ModifyCourse[key] = value
try:
update_row = ModifyCourse.update()
if update_row == 1:
return ModifyCourse,201
except Exception,e:
return {'error', e[1]},400
def join_course(self, course_id, code=None):
from models import Course, UserCourse # do this because users.py & courses.py import each other
if code is not None:
course = Course.all().filter('code =', code).get()
elif course_id is not None:
course = Course.get_by_id(course_id)
else:
return ''
if course is None:
return 'Invalid code'
if UserCourse.all().filter('user ='******'course =', course).get():
return 'You are already in the course'
if course.teacher.key().id() == self.key().id():
return 'You teach that course'
UserCourse(user=self, course=course).put()
return course
def settings():
form = CourseForm()
# courses of current user
courses = Course.query.filter_by(user_id=current_user.get_id()).all()
if form.validate_on_submit():
course = Course(
name=form.name.data,
meeting_day=form.meeting_day.data,
meeting_time=form.meeting_time.data,
price=form.price.data,
user_id=current_user.get_id()
)
db.session.add(course)
try:
db.session.commit()
except Exception:
print(Exception)
flash("Course added", "add_course")
return redirect(url_for("settings"))
return render_template("settings.html", form=form, courses=courses, page_name="settings")
def setUp(self):
"""Add sample data.
Create test client."""
db.drop_all()
db.create_all()
user1 = User.signup("*****@*****.**", "allison", "allison", "Allison", "McAllison", None)
user1.id = 1111
user2 = User.signup("*****@*****.**", "jackson", "jackson", "Jackson", "McJackson", None)
user2.id = 2222
v = Video(title="Title of a YouTube Video", description="Description of a YouTube Video", yt_video_id="yfoY53QXEnI", yt_channel_id="UC29ju8bIPH5as8OGnQzwJyA")
c = Course(title = "This course title is a test", description = "This course description is a test", creator_id = user1.id)
db.session.add(v)
db.session.add(c)
db.session.commit()
self.user1 = user1
self.user2 = user2
self.v = v
self.c = c
# set the testing client server
self.client = app.test_client()
def add_course():
title = request.json['title']
code = request.json['code']
lecturer = request.json['lecturer']
status = request.json['status']
level = request.json['level']
course = Course(code=code,
title=title,
lecturer=lecturer,
status=status,
level=level)
course = course.save()
print(course.id)
jsonify = courseSchema.dump(course)
return jsonify
def _get_or_create_course(self, course, department, instructors, attributes, restrictions, section):
course_record = Course.query.filter_by(name=course.course_name).first()
if not course_record:
course_record = Course(name=course.course_name, subject=course.subject, subject_level=course.course_number)
#print "Adding Course: \"%s-%s\"" % (course.subject, course.course_number)
self.num_new_courses += 1
if course.course_name not in self.course_names:
self.num_courses += 1
self.course_names[course.course_name] = True
course_record.department = department
course_record.attributes = attributes
course_record.restrictions = restrictions
course_record.sections.append(section)
db.session.add(course_record)
#db.session.commit()
return course_record
def test_delete_course(self):
resp = self.client.delete(f'/courses/{self.courses[0].guid}')
assert resp.status_code == 204
assert Course.get_one(guid=self.courses[0].guid) is None
assert self.client_not_logged_in.delete(f'/courses/{self.courses[0].guid}').status_code == 403
def course_add(request):
"""
FIXME: merge this and one below into two
"""
manipulator = Course.AddManipulator()
if request.method == 'POST':
# If data was POSTed, we're trying to create a new Place.
new_data = request.POST.copy()
# Check for errors.
errors = manipulator.get_validation_errors(new_data)
if not errors:
# No errors. This means we can save the data!
manipulator.do_html2python(new_data)
new_course = manipulator.save(new_data)
# Redirect to the object's "edit" page. Always use a redirect
# after POST data, so that reloads don't accidently create
# duplicate entires, and so users don't see the confusing
# "Repost POST data?" alert box in their browsers.
return HttpResponseRedirect("/score/course/%i/" % new_course.id)
else:
# No POST, so we want a brand new form without any data or errors.
errors = new_data = {}
# Create the FormWrapper, template, context, response.
form = forms.FormWrapper(manipulator, new_data, errors)
return render_to_response('scores/course_form.html', {'form': form})
def get(self):
query_text = cgi.escape(self.request.get("query"))
q = Course.all().search(query_text).fetch(50)
courses = []
for course in q:
coursevals = {'courseName': course.courseName,
'lat': course.latitude,
'lon': course.longitude,
'numholes': course.numberHoles,
'id': course.courseId,
'description': course.description.replace('\n', '<br />'),
'city': course.city,
'state': course.state,
'zip' : course.zip,
'teeType': course.teeType,
'basketType': course.basketType,
'holesLT300': course.holesLT300,
'holesBW300400': course.holesBW300400,
'holesGT400': course.holesGT400 }
courses.append(coursevals)
template_vals = {'courses': courses,
'query_text': query_text,
'gmaps_api_key': GMAPS_API_KEY,
'facebook': self.get_facebook() }
path = os.path.join(os.path.dirname(__file__), 'templates/searchpage.html')
self.response.out.write(template.render(path, template_vals))
def create_classes():
try:
print('创建班级'.center(60, '-'))
course_list = Course.get_all_obj_list()
for k, obj in enumerate(course_list):
print(k, obj, obj.name)
sid = int(input('请选择课程:'))
course_obj = course_list[sid]
name = input('请输入班级名:').strip()
tuition = input('请输入学费:').strip()
classes_name_list = [obj.name for obj in Classes.get_all_obj_list()]
if name in classes_name_list:
raise Exception('\033[43;1m班级[%s] 已存在，不可重复创建\033[0m' % name)
obj = Classes(name, tuition, course_obj.nid)
obj.save()
status = True
error = ''
data = '\033[33;1m班级[%s] 学费[%s] 创建成功\033[0m' % (obj.name, obj.tuition)
except Exception as e:
status = False
error = str(e)
data = ''
return {'status': status, 'error': error, 'data': data}
def addcourse(request):
category = 'Course'
if request.method == 'POST':
form = CourseForm(request.POST)
if form.is_valid():
s = Course(name=form.cleaned_data["name"],
code=form.cleaned_data["code"],
classroom=form.cleaned_data["classroom"],
times=form.cleaned_data["times"]
)
s.save()
return HttpResponseRedirect('/all_courses/')
else:
form = CourseForm()
return render_to_response('add.html', {'form': form, 'type': category}, RequestContext(request))
def create_course_to_teacher():
print('课程导师'.center(60, '='))
course_list = Course.get_all_obj_list()
for k, obj in enumerate(course_list):
print(k, obj, obj.name)
sid = int(input('请选择课程: '))
course_obj = course_list[sid]
teacher_list = Teacher.get_all_obj_list()
for k, obj in enumerate(teacher_list):
print(k, obj, obj.name)
sid = int(input('请选择关联导师: '))
teacher_obj = teacher_list[sid]
classes_list = Classes.get_all_obj_list()
for k, obj in enumerate(classes_list):
print(k, obj, obj.name)
sid = int(input('请选择负责班级: '))
classes_obj = classes_list[sid]
obj = Course_to_teacher(course_obj.nid, teacher_obj.nid, classes_obj.nid)
obj.save()
status = True
error = ''
data = '\033[33;1m课程[%s] 班级[%s] 导师[%s] 分配成功\033[0m' % (
course_obj.name, classes_obj.name, teacher_obj.name)
return {'status': status, 'error': error, 'data': data}
def post(self):
from models import Course, Progress
user = users.get_current_user()
course_numbers = (self.request.get_all('courses[]'))
current_user = User.all().filter('email =', user.email()).get()
myclasses = []
myclasses2 = []
for classy in course_numbers:
test = [x.strip() for x in classy.split(',')]
myclasses.append(test)
for classy in myclasses:
coursename = classy[0].replace(" ", "")
coursetime = classy[1]
myclasses2.append((coursename,coursetime))
# [u'Fall12,PHYS 5A,Fall12,PHYS 5L,Fall12,CMPS 12B,Fall12,CMPS 12L,Fall12,CMPE 16,',
# u'Winter13,HCI 131 ,Winter13,CMPS 101 ,Winter13,DANM 250,Winter13,Math 21 ,',
# u'Spring13,PHYSC 5C,Spring13,PHYSC 5L,Spring13,AMS 131,',
# u'Summer13,CMPS109,Summer13,Math 24,']
# myclasses = filter(None, myclasses)
# test = [x.strip() for x in myclasses[0].split(',')]
progCheck = Progress.all().filter('user ='******'number =',coursename).get()
progress = Progress(user=current_user, course=course, completed=True, quarter=quarter, year=year)
if (course != None):
progress.put()
# if (course != None):
# quarter = course_number[1][:-2]
# year = int(course_number[1][-2:])
# # need to figure out how to query for specific course
# # so that we can remove it if neccessary
# progress = Progress(user=current_user, course=course, completed=True, quarter=quarter, year=year)
# progCheck = Progress.all().filter('user ='******'course =', course).fetch(limit=20)
# # if (progCheck.quarter != quarter):
# # progress.put()
# # #then remove the old class here too....
log = ""
# if not progCheck:
# progress.put()
# log = "progCheck==None , " + str(course_number)
# else:
# if not any(quarter == chances.quarter for chances in progCheck):
# progress.put()
# # for chances in progCheck:
# # if (chances.quarter != quarter):
# # itsHere
# progress.put()
self.response.write(log + str(myclasses2));
def mypost(self):
course = self.adderr(Course.create(
self.user,
self.request.get('name'),
self.request.get('mode'),
))
if not self.err:
self.redirect(OPEN_COURSE_URL + str(course.key().id()))
def get(self):
course_list = {}
my_courses = {}
user = self.get_user()
my_courses = UserCourse.gql('WHERE user=:1',user['user'])
course_list = Course.gql('ORDER BY course').fetch(50)
self.render('signup-2.html',my_courses=my_courses,course_list=course_list)
def get(self):
logging.info("Starting to clean the datastore")
courses = Course.query()
for key in courses.iter(keys_only=True):
files = File.query(ancestor=key)
if files.get() is None:
key.delete()
logging.info("Deleting: " + key.string_id())
logging.info("Done cleaning the datastore")
def get(self):
#add initial universities
inst = Inst.all().fetch(50)
if len(inst)==0:
new_inst = Inst()
new_inst.name = 'Other'
new_inst.put()
#add also introductory course
courses = ['Electrical Engineering','Mechanical Engineering','Civil Engineering','Software Engineering','Geospatial Engineering','Business Courses','Accounts','Commerce',
'Economics','Pure Mathematics','Statistics','Info Tech Courses','Computer Science','Computer Technology','Informatics','Computer Security & Forensics','Nursing',
'Medical Laboratory','Biochemestry','Biotechnology','Microbiology','Applied Physics','Industrial Chemistry','Analytical Chemistry','Astronomy & Astrophysics',
'Applied Chemistry','Sociology','Journalism','Counselling Psychology','Forestry','Physical Education']
for c in courses:
course = Course()
course.course = c
course.put()
self.redirect('/home')
def get(self):
from models import Course, Prerequisites
courses = Course.all().order('department').fetch(limit=1000)
print courses
output = {
'courses': courses,
}
path = os.path.join(os.path.dirname(__file__), 'templates/prereqs.html')
self.response.write(template.render(path, output))
def create_course(request):
if request.method == 'POST':
name=request.POST.get('course-name','')
# print "course is : ", name
number = request.POST.get('max-number','')
try:
c = Course.objects.get(name__exact=name)
if c:
message="Class Already Exist!"
return render_to_response('home.html',RequestContext(request,{'title':'TeacherHome','message':message}))
except:
print "course does not exists"
user = request.user
cou = Course(name=name,teacher=user.id)#,max_number=number)
cou.save()
#yield render_to_response('home.html',RequestContext(request,{'title':'TeacherHome','message':'Create Success!'}))
return HttpResponseRedirect(reverse('teacher_home'))
def test_id_syntax(self):
with self.assertRaises(DataError):
with transaction.atomic():
tis_cc0 = CourseCategory(id='123456789', description='too long')
tis_cc0.save()
with self.assertRaises(ValidationError):
with transaction.atomic():
tis_cc1 = CourseCategory(id='has spc', description='will not work')
tis_cc1.full_clean()
with self.assertRaises(ValidationError):
with transaction.atomic():
tis_c0 = Course(id='has space', cat=self.cc0, description='who cares')
tis_c0.full_clean()
with self.assertRaises(ValidationError):
with transaction.atomic():
tis_lo0 = LearningObjective(id='has space', course=self.c0, description='foobar')
tis_lo0.full_clean()
def get(self):
# self.addcourses()
s = Source.query()
if s.count(limit=1) == 0:
self.redirect('/addsource')
else:
c = Course.query()
context = {'courses': c, 'sources': s}
self.render('classes.html', context)
def test_creation(self):
self.assertIsNotNone(
Course.create(self.teacher, '', ''),
'Empty course name'
)
self.assertIsNone(
Course.create(self.teacher, 'pub', ''),
'Create public course'
)
self.assertIsNotNone(
Course.create(self.teacher, 'Pub', ''),
'Recreate public course (bad)'
)
self.assertIsNone(
Course.create(self.teacher, 'Pub2', None),
'Create public course'
)
self.assertIsNone(
Course.create(self.teacher, 'pvt', 'on'),
'Create private course'
)
for name, private in [('Pvt', True), ('Pub', False), ('Pub2', False)]:
course = Course.all().filter('name =', name).get()
self.assertIsNotNone(course)
if private:
self.assertIsNotNone(course.code)
else:
self.assertIsNone(course.code)
self.assertEqual(course.teacher.email, self.teacher.email)
