def test_drop_student(client):
Course.objects().delete()
client.post("/api/class/add",
json={
"course_id": 20000,
"title": "Introduction to Computers",
"description": "",
"instructor": 500,
"start_date": "2016-09-01",
"end_date": "2016-12-01"
})
r = client.get("/api/class/20000/drop/100")
assert r.status_code == 200
assert r.get_json()["error"] == 1
client.get("/api/class/20000/enroll/100")
r = client.get("/api/class/20000/drop/100")
assert r.status_code == 200
assert r.get_json()["error"] == 0
r = client.get("/api/class/20000")
assert r.get_json()["enrolled_students"] == []
r = client.get("/api/class/10000/drop/100")
assert r.status_code == 404
Course.objects().delete()
def import_bundle(bundle, owner_id, course_id=None, update=True):
if 'course' in bundle:
course = Course.decode_json(bundle['course'], owner_id=owner_id)
db.session.add(course)
db.session.commit()
else:
course = Course.by_id(course_id)
assignment_remap = {}
assignments = bundle.get('assignments', [])
for assignment_data in natsorted(assignments, key=lambda a: a['name']):
assignment = Assignment.decode_json(assignment_data,
course_id=course.id,
owner_id=owner_id)
assignment_remap[assignment_data['url']] = assignment.id
group_remap = {}
groups = bundle.get('groups', [])
for group_data in natsorted(groups, key=lambda g: g['name']):
group = AssignmentGroup.decode_json(group_data,
course_id=course.id,
owner_id=owner_id)
group_remap[group_data['url']] = group.id
memberships = bundle.get('memberships', [])
for member_data in sorted(memberships, key=sorter):
assignment_id = assignment_remap[member_data['assignment_url']]
group_id = group_remap[member_data['assignment_group_url']]
member = AssignmentGroupMembership.decode_json(
member_data,
assignment_id=assignment_id,
assignment_group_id=group_id)
return True
def test_add_course_announcement(client):
Course.objects().delete()
client.post("/api/class/add",
json={
"course_id": 20000,
"title": "Introduction to Computers",
"description": "",
"instructor": 500,
"start_date": "2016-09-01",
"end_date": "2016-12-01"
})
text = "Welcome to the course ABC!"
text2 = "Welcome to the course XYZ!"
response = client.post("/api/class/20000/announcement/add",
json={"text": text})
assert response.status_code == 200
response = client.post("/api/class/20000/announcement/add",
json={"text": text2})
assert response.status_code == 200
response = client.get("/api/class/20000")
assert text == response.get_json()['announcements'][0]['text']
assert text2 == response.get_json()['announcements'][1]['text']
response = client.post("/api/class/10000/announcement/add",
json={"text": text})
assert response.status_code == 404
Course.objects().delete()
def test_get_courses(client):
Course.objects().delete()
client.post("/api/class/add",
json={
"course_id": 20000,
"title": "Introduction to Computers",
"description": "",
"instructor": 500,
"start_date": "2016-09-01",
"end_date": "2016-12-01"
})
client.post("/api/class/add",
json={
"course_id": 10000,
"title": "Introduction to Biology",
"description": "",
"instructor": 300,
"start_date": "2016-09-01",
"end_date": "2016-12-01"
})
r = client.get("/api/class")
assert r.status_code == 200
data = r.get_json()
assert len(data) == 2
ids = [c["course_id"] for c in data]
assert 10000 in ids and 20000 in ids
Course.objects().delete()
def test_get_course_announcements(client):
Course.objects().delete()
r = client.get("/api/class/20000/announcement")
assert r.status_code == 404
client.post("/api/class/add",
json={
"course_id": 20000,
"title": "Introduction to Computers",
"description": "",
"instructor": 500,
"start_date": "2016-09-01",
"end_date": "2016-12-01"
})
msgs = [
"This is an easy class.", "This class is tough.",
"This is an OK class.", "This class is taught by Mr. Musk."
]
for m in msgs:
client.post("/api/class/20000/announcement/add", json={"text": m})
r = client.get("/api/class/20000/announcement")
assert r.status_code == 200
assert msgs == [a["text"] for a in r.get_json()["announcements"]]
def run(self, owner_id, course_data_path, **kwargs):
from models.models import AssignmentGroupMembership
from models.course import Course
from models.assignment import Assignment
from models.assignment_group import AssignmentGroup
with open(course_data_path, 'r') as input_file:
imported_data = json.load(input_file)
Course.import_json(imported_data, int(owner_id))
def step_impl(context):
for row in context.table:
try:
Course.get(Course.name == row['name'])
except Course.DoesNotExist:
Course.create(name=row['name'],
provider_id=row['provider_id'],
spec_id=row['spec_id'])
def setUp(self):
self.student = Student('test1', 123)
self.course1 = Course(1, 'test_course1')
self.course2 = Course(2, 'test_course2')
self.course3 = Course(3, 'test_course3')
self.course4 = Course(4, 'test_course4')
self.enrollment1 = Enrollment(self.student, self.course1)
self.enrollment2 = Enrollment(self.student, self.course2)
self.enrollment3 = Enrollment(self.student, self.course3)
def transform_to_anti_req_obj(anti_req_string):
anti_req_obj = AntiRequisites()
# Split the string on various delimiters
# Replace is to replace any 'and' joiners at the end of lists
split_anti_req_string = re.split(r', and |, the former |, ', anti_req_string.replace('B and ', ', '))
anti_req_course_list = []
for course_name in split_anti_req_string:
# If the course_name has more than one course joined by 'or'
if 'B or ' in course_name:
list_of_or_courses = []
for course in course_name.split(' or '):
course_dept_and_code = course.rsplit(' ', 1)
temp_course = Course(course_dept_and_code[0], re.sub("[^0-9]", "", course_dept_and_code[1]),
re.sub("[^A-Z/]", "", course_dept_and_code[1]))
list_of_or_courses.append(temp_course)
setattr(anti_req_obj, 'one_of', list_of_or_courses)
# If course_name contains an anti-req taken during a specific session (Fall/Winter, Summer, etc.)
elif 'if taken during' in course_name:
course_name_list = course_name.split(' if taken during ')
course_dept_and_code = course_name_list[0].rsplit(' ', 1)
temp_course = Course(course_dept_and_code[0], re.sub("[^0-9]", "", course_dept_and_code[1]),
re.sub("[^A-Z/]", "", course_dept_and_code[1]))
school_session = course_name_list[1].replace('the ', '')
# If the course_name contains the phrase 'academic year', that means full year
if 'academic year' in course_name_list[1]:
year_anti_req_map = {
'term': 'Year',
'years': school_session.split(' ', 1)[0].split('-')
}
setattr(temp_course, 'if_taken_in', year_anti_req_map)
# Else, all other instances can be processed into session and years
else:
year_anti_req_map = {
'term': school_session.split(' ', 1)[0],
'years': school_session.split(' ', 1)[1].replace(' or ', ',').split(' ')[0].split(',')
}
setattr(temp_course, 'if_taken_in', year_anti_req_map)
# Append the course object to the anti-req course list
anti_req_course_list.append(temp_course)
# No special handling, split into course dept and course code and create Course obj
else:
course_dept_and_code = course_name.rsplit(' ', 1)
temp_course = Course(course_dept_and_code[0], re.sub("[^0-9]", "", course_dept_and_code[1]),
re.sub("[^A-Z/]", "", course_dept_and_code[1]))
anti_req_course_list.append(temp_course)
anti_req_obj.course_list = anti_req_course_list
return anti_req_obj
def add():
""" Create a new assignment with the given information
"""
add_form = AddCourseForm(request.form)
if request.method == 'POST':
Course.new(name=add_form.name.data,
owner_id=g.user.id,
visibility=add_form.visibility.data)
flash('New course added')
return redirect(url_for('courses.index'))
return render_template('courses/add.html', add_form=add_form)
def seedCourses():
for i in range(0,5):
name = 'Course_%s' % i
description = str(i * 3)
department_name = str(i * 9)
c = Course(
name = name,
description = description,
department_name = department_name
)
c.put()
def remove_course(course_id):
course_id = int(request.values.get('course_id'))
course = Course.by_id(course_id)
# Verify exists
check_resource_exists(course, "Course", course_id)
# Verify permissions
require_course_instructor(g.user, course_id)
# Perform action
Course.remove(course_id)
flash('Course removed')
return redirect(url_for('courses.index'))
def rename_course():
course_id = int(request.values.get('course_id'))
course = Course.by_id(course_id)
# Verify exists
check_resource_exists(course, "Course", course_id)
# Verify permissions
require_course_instructor(g.user, course_id)
# Perform action
new_name = request.values.get('name')
Course.rename(course_id, new_name)
return jsonify(success=True)
def run(self, site, messages=None):
site.clear()
show_messages(messages)
serial = get_input('Course Serial: ')
title = get_input('Title: ')
course = Course(serial=serial, title=title, owner=site.active_user)
if course.is_valid(site.course_list):
site.add_course(course)
else:
return course.errors
return None
def get_course(id):
sql = "Select * from courses where id = %s"
cursor = connection.cursor()
cursor.execute(sql, [id])
record = cursor.fetchone()
course = Course(id=record[0],
name=record[1],
start_date=record[3],
end_date=record[4],
cost=record[6])
course.type = CourseTypeDao.get_course_type(record[2])
course.grading_format = GradingFormatDao.get_format(record[5])
return course
def create(self):
params = self.request.body
validator=Validator(params,'create',CourseHandler.valid_model)
new_course_data = validator.good_create_request()
if new_course_data:
new_course=Course(
name = new_course_data['name'],
description = new_course_data['description'],
department_name = new_course_data['department_name'],
)
new_course.put()
self.response.write(json.dumps(new_course.dict()))
else:
self.response.write(json.dumps(validator.error_message()))
def run(self, **kwargs):
from models.user import User
from models.course import Course
from models.role import Role
with open('settings/secrets.json', 'r') as secret_file:
secrets = json.load(secret_file).get("ADMIN", {})
print("Adding Admin")
admin = User(first_name=secrets.get("first_name", "Admin"),
last_name=secrets.get("last_name", "User"),
password=hash_password(secrets.get(
"password", "password")),
confirmed_at=datetime.datetime.now(),
active=True,
email=secrets.get("email", "*****@*****.**"))
db.session.add(admin)
db.session.flush()
db.session.add(Role(name='instructor', user_id=admin.id))
db.session.add(Role(name='admin', user_id=admin.id))
print("Adding default course")
default_course = Course(name="Default Course",
owner_id=admin.id,
service="native")
db.session.add(default_course)
db.session.flush()
db.session.add(
Role(name='instructor',
course_id=default_course.id,
user_id=admin.id))
db.session.commit()
print("Complete")
def setUp(self):
student = Student('test', 1)
course = Course(1, 'test_course')
datetime_format = '%Y-%m-%dT%H:%M:%SZ'
assignment = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course,
datetime_format)
self.grade = Grade(student, course, assignment, 0.85)
def get(self):
search = self.request.get('query')
results = Course.find_with_partial_title(search)
obj = {
'courses': map(lambda x: x.as_json(), results)
}
render_json(self, obj=obj)
def create(course_name,user_id,post_id):
print('posts.create is working!')
# print("inside posts create func :",course_name)
user = User.get_or_none(User.id == user_id)
current_course = Course.get_or_none(Course.title == course_name)
# print("current_course ",current_course)
for thread in current_course.thread:
course_thread = thread
# print("current_course thread ",course_thread)
if request.form.get("comment"):
new_comment = Comment(content=request.form.get("comment"), post=post_id, user=user)
new_comment.save()
else:
if "assignment" in request.files:
file = request.files["assignment"]
# file.filename = secure_filename(file.filename)
file_path = upload_file_to_s3(file, user.username)
content = request.form.get("post_content")
new_post = Post(post_content=content, thread=course_thread,user=user, file_path=file_path)
new_post.save()
else:
content = request.form.get("post_content")
new_post = Post(post_content=content, thread=course_thread,user=user)
new_post.save()
return redirect(url_for('courses.show', course_title=course_name, user_id=user_id))
def getCourseByCourseId(self, course_id):
"""
获取课程模型
:param course_id: 课程id
:return: 存在返回course对象，否则返回None
"""
sql = "SELECT * FROM course WHERE id=%s"
self.cursor.execute(sql, course_id)
res = self.cursor.fetchall()
course = None
err = ErrorCode.NoError
if len(res) == 0:
err = ErrorCode.ResourceNotFoundError
else:
dict = res[0] # 返回是一个列表，取第一个（也只有一个）
course = Course(id=str(dict["id"]),
name=dict["name"],
key=dict["key"],
creator_id=str(dict["creator_id"]),
create_timestamp=dict["create_timestamp"],
status=dict["status"],
notice=dict["notice"],
introduction=dict["introduction"],
joinable=dict["joinable"])
return course, err
def submissions_user(course_id, owner_id):
''' List all the users in the course '''
course_id = int(course_id)
course = Course.by_id(course_id)
check_resource_exists(course, "Course", course_id)
user, user_id = get_user()
if course_id is not None:
is_grader = user.is_grader(course_id)
else:
is_grader = False
is_owner = user_id == maybe_int(owner_id)
if not is_grader and not is_owner:
return "You are not an instructor or the owner of the assignment!"
owner = User.by_id(maybe_int(owner_id))
assignments = natsorted(course.get_submitted_assignments(),
key=lambda r: r.name)
all_subs = Submission.by_student(owner_id, course_id)
all_subs = {s[0].assignment_id: s for s in all_subs}
submissions = [all_subs.get(assignment.id, (None, None, assignment))
for assignment in assignments]
return render_template('courses/submissions_user.html',
course_id=course_id,
assignments=assignments,
submissions=submissions,
owner=owner,
is_instructor=is_grader)
def submissions_filter(course_id):
''' List all the users in the course '''
is_grader = g.user.is_grader(int(course_id))
if not is_grader:
return "You are not an instructor or TA in this course!"
course_id = int(course_id)
course = Course.by_id(course_id)
students = natsorted(course.get_students(), key=lambda r: r.name())
assignments = natsorted(course.get_submitted_assignments(),
key=lambda r: r.name)
criteria = request.values.get("criteria", "none")
search_key = int(request.values.get("search_key", "-1"))
submissions = []
if criteria == "student":
all_subs = Submission.by_student(search_key, course_id)
all_subs = {s[0].assignment_id: s for s in all_subs}
submissions = [
all_subs.get(assignment.id, (None, None, assignment))
for assignment in assignments
]
elif criteria == "assignment":
all_subs = Submission.by_assignment(search_key, course_id)
all_subs = {s[0].user_id: s for s in all_subs}
submissions = [
all_subs.get(student.id, (None, student, None))
for student in students
]
return render_template('courses/submissions_filter.html',
course_id=course_id,
assignments=assignments,
students=students,
submissions=submissions,
criteria=criteria,
search_key=search_key,
is_instructor=is_grader)
def dashboard(lti=lti):
"""
:type lti: controllers.pylti.flask.lTI
"""
if 'user' not in g and not g.user:
return "You are not logged in."
course_id = get_course_id()
user, user_id = get_user()
if course_id is None:
return "You are not in a course context."
is_grader = user.is_grader(course_id)
if is_grader:
return grader_dashboard(user, course_id)
course = Course.by_id(course_id)
assignments = natsorted(course.get_submitted_assignments(),
key=lambda r: r.name)
all_subs = Submission.by_student(user_id, course_id)
all_subs = {s[0].assignment_id: s for s in all_subs}
submissions = [
all_subs.get(assignment.id, (None, None, assignment))
for assignment in assignments
]
return render_template('courses/dashboard.html',
embed=True,
course_id=course_id,
user=user,
is_grader=is_grader,
submissions=submissions,
criteria='student')
def _get_open_courses(data):
req = requests.post(url, data=data)
soup = BeautifulSoup(req.content, 'html5lib')
rows = soup.select('table.dataentrytable tbody tr')
open_courses = list()
# The first row is the header row with the column labels
# If there's only one row, the rest of the table is empty, so there are no results
if len(rows) > 1:
rows = rows[1:]
for row in rows:
cells = row.select('td')
cells_text = list(map(lambda x: x.get_text(), cells))
crn = cells_text[0].strip()
label = cells_text[1].strip()
title = cells_text[2].strip()
professor = cells_text[6].strip()
open_courses.append(Course(crn, label, title, professor))
return open_courses
def get_assignments():
assignment_ids = request.values.get('assignment_ids', "")
course_id = get_course_id()
user, user_id = get_user()
# TODO: verify that they have the permissions to see these assignments
assignments, groups = [], []
errors = []
if not assignment_ids:
course: Course = Course.by_id(course_id)
check_resource_exists(course, "Course", course_id)
grouped_assignments = natsorted(
course.get_submitted_assignments_grouped(),
key=lambda r:
(r.AssignmentGroup.name
if r.AssignmentGroup is not None else None, r.Assignment.name))
assignments = [a.Assignment.encode_json() for a in grouped_assignments]
groups = [
a.AssignmentGroup.encode_json()
if a.AssignmentGroup is not None else None
for a in grouped_assignments
]
else:
for assignment_id in assignment_ids.split(","):
if not assignment_id.isdigit():
errors.append(f"Unknown Assignment ID: {assignment_id!r}")
assignment_id = int(assignment_id)
# With Course Role Information
assignment = Assignment.by_id(assignment_id)
check_resource_exists(assignment, "Assignment", assignment_id)
assignments.append(assignment.encode_json())
return ajax_success(
dict(assignments=assignments, errors=errors, groups=groups))
def show(course_title, user_id):
user = User.get_by_id(user_id)
current_course = Course.get_or_none(Course.title == course_title)
students = []
for info in StudentCourse.select().join(Course).where(
Course.title == course_title):
for student in User.select().where(User.id == info.student_id):
students.append(student)
for thread in current_course.thread:
course_thread = thread
course_posts = []
for post in Post.select().where(Post.thread_id == course_thread):
course_posts.append(post)
course_posts.reverse()
return render_template('courses/show.html',
course_title=course_title,
students=students,
course_posts=course_posts,
user=user)
def dashboard(lti=lti, lti_exception=None):
"""
:type lti: controllers.pylti.flask.lTI
"""
force_default_assignment = maybe_bool(request.values.get('force_default_assignment', "false"))
if 'user' not in g and not g.user:
return "You are not logged in."
course_id = get_course_id()
user, user_id = get_user()
if course_id is None:
return "You are not in a course context."
is_grader = user.is_grader(course_id)
if is_grader and not force_default_assignment:
return grader_dashboard(user, course_id)
course = Course.by_id(course_id)
assignment = course.get_default_assignment()
if assignment is not None:
return redirect(url_for("blockpy.load", assignment_id=assignment.id,
course_id=course_id, user_id=user_id, force_download=False,
embed=True))
else:
# No default assignment!
assignments = natsorted(course.get_submitted_assignments(),
key=lambda r: r.name)
all_subs = Submission.by_student(user_id, course_id)
all_subs = {s[0].assignment_id: s for s in all_subs}
submissions = [all_subs.get(assignment.id, (None, None, assignment))
for assignment in assignments]
return render_template('courses/dashboard.html', embed=True,
course_id=course_id, user=user, is_grader=is_grader,
submissions=submissions, criteria='student')
def test_delete_course_announcement(client):
Course.objects().delete()
client.post("/api/class/add",
json={
"course_id": 20000,
"title": "Introduction to Computers",
"description": "",
"instructor": 500,
"start_date": "2016-09-01",
"end_date": "2016-12-01"
})
msgs = [
"This is an easy class.", "This class is tough.",
"This is an OK class.", "This class is taught by Mr. Musk."
]
for m in msgs:
client.post("/api/class/20000/announcement/add", json={"text": m})
r = client.get("/api/class/20000/announcement/delete/4")
assert r.status_code == 404
r = client.get("/api/class/20000/announcement/delete/2")
assert r.status_code == 200
r = client.get("/api/class/20000")
announcements = r.get_json()["announcements"]
assert len(announcements) == 3
assert announcements[0]["text"] == msgs[0]
assert announcements[1]["text"] == msgs[1]
assert announcements[2]["text"] == msgs[3]
r = client.get("/api/class/20000/announcement/delete/0")
assert r.status_code == 200
r = client.get("/api/class/20000/announcement/delete/0")
assert r.status_code == 200
r = client.get("/api/class/20000")
assert r.get_json()["announcements"][0]["text"] == msgs[3]
r = client.get("/api/class/10000/announcement/delete/10")
assert r.status_code == 404
Course.objects().delete()
def delete(self,course_id):
validator = Validator(course_id,'delete',CourseHandler.valid_model)
course = Course.get_by_id(int(course_id))
if course:
course.key.delete()
self.response.write(json.dumps(validator.success_message()))
else:
self.response.write(json.dumps(validator.error_message()))
def show(self,course_id):
course = Course.get_by_id(int(course_id))
if course:
self.response.write(json.dumps(course.dict()))
else:
""" Interesting thing here is validator doesn't really need to be called... """
validator = Validator(course_id,"show",CourseHandler.valid_model)
self.response.write(json.dumps(validator.error_message()))
def fix_course_outcome_url():
new_url = request.values.get("new_url")
course_id = get_course_id()
user, user_id = get_user()
require_course_instructor(user, course_id)
course = Course.by_id(course_id)
course.update_endpoint(new_url)
return ajax_success({"success": "True"})
def interm_js_themes(context):
#create course
try:
context.course = Course.get(
Course.name.where(Course.name == 'Intermediate JavaScript'))
except Course.DoesNotExist:
Course.create(course_name='Intermediate JavaScript')
context.course = Course.select().where(
Course.name == 'Intermediate JavaScript')
context.student_id = 1
#create themes
try:
context.themes_list = context.course.get_themes()
except CourseTheme.DoesNotExist:
for row in context.table:
CourseTheme.create(course_id=row['course_id'],
name=row['name'],
points=row['points'])
def student_can_get_certificate(student_id, course_id, ud_course_id):
if ud_course_id:
student_perc = StudentFinishedTheme.select().where(
StudentFinishedTheme.student_id == student_id
& StudentFinishedTheme.us_course_id == ud_course_id).count()
needed_perc = Course.select(Course.certificate_get).where(
UserDefinedCourse.ud_course_id == ud_course_id).certificate_get
else:
student_perc = StudentFinishedTheme.select().where(
StudentFinishedTheme.student_id == student_id
& StudentFinishedTheme.course_id == course_id).count()
needed_perc = Course.select(Course.certificate_get).where(
Course.course_id == course_id).certificate_get
if student_perc >= needed_perc:
return True
return False
def get_courses(self, html):
tbody = re.findall(r"<tbody[^>]*>[\s\S]*?</tbody>\s*", html)[0]
courses = re.findall(r"<tr[^>]*>[\s\S]*?</tr>\s*", tbody)
for i, course_data in enumerate(courses):
course = Course(course_data)
courses[i] = course
return courses
def get(self):
restid = request.args.get('id')
rests = Rest.get_rest_object(restid)
pics = Photo.get_rest_pics(restid)
reviews = Review.get_rest_reviews(restid)
for review in reviews:
review.menu = Course.get_courses(review.revid)
return render_template('rest_index.html', pics=pics, reviews=reviews, rests=rests)
def post(self):
"""
Creates a new course object with some title
Automatically adds the user to the course, and the course to the user
"""
title = self.request.get('title')
course = Course.new(title)
self.auth.user.add_course(course)
self.redirect(course.url)
def post(self):
"""
Add a user to a course
Note: Does not use the decorator, because the user does not belong
to the course yet
"""
course_token = self.request.get('key')
course = Course.find_with_key(course_token)
self.auth.user.add_course(course)
render_json(self)
def post(self):
op = request.form.get("op")
if op == "search":
keyword = request.form.get("keyword")
return redirect(url_for("search_result") + "?keyword=" + keyword)
elif op == "review":
restid = request.form.get("restid")
rating = request.form.get("rating")
content = request.form.get("review_content")
country = request.form.get("country")
revid = Review.insert(restid, float(rating), content, country)
menuid = Menu.insert_menu(int(restid), int(revid))
for i in request.form:
if i.startswith("menu"):
course = request.form.get(i).split(":")
Course.insert_course(menuid, course[0], course[1])
return redirect(url_for("rest_index") + "?id=" + restid)
def update(self,course_id):
course = Course.get_by_id(int(course_id))
params = self.request.body
validator=Validator(params,'update',CourseHandler.valid_model)
course_update_data = validator.good_update_request()
if course and course_update_data:
if 'name' in course_update_data.keys():
course.name = course_update_data['name']
if 'description' in course_update_data.keys():
course.description = course_update_data['description']
if 'department_name' in course_update_data.keys():
course.department_name = course_update_data['department_name']
course.put()
self.response.write(json.dumps(course.dict()))
else:
self.response.write(json.dumps(validator.error_message()))
def post(self, username):
course_fields = ['mode', 'title', 'info', 'time', 'location']
course = Course()
try:
for key in course_fields:
course.set(key, self.get_argument(key, ""))
course.user = username
course.save()
self.redirect('user'+username)
except LeanCloudError, e:
pass
def get(self):
[Course.new(name) for name in names]
self.response.write('Seed Complete!')
data = {}
if request.action == "list":
data['ss'] = Student.find().limit(50).sort({'name': 1})
local.views.students(data)
else:
myStudent = Student.findOne(request.s__id, True)
if request.action == "Delete":
myStudent.remove()
response.sendRedirectTemporary("/students")
else:
data['courses'] = Course.find().toArray()
if request.action == "Save":
Forms.fillInObject("s_", myStudent, request)
if myStudent._new:
myStudent._new = False
myStudent.save()
data['msg'] = "Saved"
if request.action == "Add" and 'course_for' in request \
and 'score' in request:
course_id = request.course_for
c = Course.findOne(course_id)
if c == None:
def deleteAll():
ndb.delete_multi(Assignment.query().fetch(keys_only=True))
ndb.delete_multi(Course.query().fetch(keys_only=True))
ndb.delete_multi(Grade.query().fetch(keys_only=True))
ndb.delete_multi(Student.query().fetch(keys_only=True))
from _10gen import request, local, Forms
from models.course import Course
data = {}
data['cs'] = Course.find().limit( 100 ).sort( { 'name' : 1 } )
template = local.views.courses
action = request.get("action", None)
if "c__id" in request:
data['c'] = Course.findOne( request.c__id )
if action == "list":
# already setup
pass
elif data.has_key('c') and action == "Delete":
data['c'].remove()
del data['c']
elif data.has_key('c') and action == "Edit":
pass
elif action == "Save":
data['c'] = data.get('c', Course())
Forms.fillInObject("c_", data['c'], request)
data['c'].save()
del data['c']
elif action == "New":
data['c'] = Course()
if data.has_key('c'):
def index(self):
courses = Course.query()
course_arr = []
for course in courses:
course_arr.append(course.dict())
self.response.write(json.dumps(course_arr))
