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))