Exemple #1
0
class StudentDAO:
    studentTable = {
        "thong": Student("ST2", "Dinh Dat Thong", True, "18-09-1997"),
        "son": Student("ST3", "Nguyen Ngoc Son", False, "04-05-1996")
    }

    location = "database/studentTable"

    def createTable(self):
        # if file existed
        if Path(self.location).is_file():
            return

        f = open(self.location, "wb")
        f.write(pickle.dumps(self.studentTable))
        f.close()

    def readFromFile(self):
        f = open(self.location, "rb")
        table = pickle.loads(f.read())
        return table

    def selectAll(self):
        return self.readFromFile()

    def selectOne(self, id):
        table = self.readFromFile()

        if id in table:
            student = table[id]
            return student

        return None
def get_students():

    for i, row in enumerate(open('data/student_counts.csv')):
        data = row.rstrip().split(",")

        (district_name, county_name, total_count, shelter_count, sharing_count, 
        unsheltered_count, motel_count, year) = data

        for i in range(int(shelter_count)-1):
            student = Student(county=county_name, living_situation="shelter", year=year)
            db.session.add(student)

        for i in range(int(sharing_count)-1):
            student = Student(county=county_name, living_situation="sharing", year=year)
            db.session.add(student)

        for i in range(int(unsheltered_count)-1):
            student = Student(county=county_name, living_situation="unsheltered", year=year)
            db.session.add(student)

        for i in range(int(motel_count)-1):
            student = Student(county=county_name, living_situation="motel", year=year)
            db.session.add(student)

    db.session.commit()
Exemple #3
0
    def post(self):

        subject=self.get_argument('subject')
        student=self.get_argument('student',default="")

        s=Subject.objects(id=ObjectId(subject)).first()
        if not s:
            return self.write({'err':'课题不存在'})

        if s.professor.username!=self.current_user.username:
            return self.write({'err':'不是你的课题'})

        if s.selected_by==[]:
            return self.write({'err':'不可改选上阶段选好的课题'})

        # Clear previous approvement
        if s.applied_to:
            u=Student.objects(username=s.applied_to.username).first()
            u.applied_to=None
            u.save()
            s.applied_to=None

        if student:
            for u_embedded in s.selected_by:
                u=Student.objects(username=u_embedded.username).first()
                if u.username==student:
                    # You are the one!
                    s.applied_to=u
                    u.applied_to=s
                u.save()

        s.save()

        self.write({})
Exemple #4
0
def dels():
    if request.method == "POST":
        student = Student(request.form['idn'], '', '', '', '', '')
        student.delete_student()
        return render_template('home.html')
    else:
        return render_template('delstudent.html')
Exemple #5
0
	def submit_all():
		result = askquestion(title="Confirmation", message= "Do you want to process?")

		if result == "yes":
			person = Person()
			person.lname = input_lastname.get(1.0, "end-1c")
			person.fname = input_firstname.get(1.0, "end-1c")
			person.birthday = datetime.date(birthYear.get(), months.index(birthMonth.get()) + 1, birthDay.get())
			person.nationality = selected_nationality.get()
			person.gender = selected_gender.get()
			person.streetNumber = str(input_houseNo.get(1.0, "end-1c")) + str(input_houseNo2.get(1.0, "end-1c"))
			person.streetname = input_street.get(1.0, "end-1c")
			person.city = input_city.get(1.0, "end-1c")
			person.postalCode = str(input_postal.get(1.0, "end-1c")) + str(input_postal2.get(1.0, "end-1c"))
			person.phone = input_phoneNumber.get(1.0, "end-1c")
			person.email = input_email.get(1.0, "end-1c")
			person.insert()

			student = Student()
			student.personID = person.personID
			student.studentID = int(input_studentID.get(1.0, "end-1c"))
			student.startYear = datetime.date(startYear.get(), 1, 1)
			student.enrolled = selected_study.get()
			counseler_index = counsellornames.index(selected_counsellor.get())
			student.studyCouncelor = counsellors[counseler_index].teacherID
			student.insert()

			person.userName = (person.lname + str(student.studentID))
			person.userPass = "******"
			person.update()
		
			ui.AdminWindowStudents.admin_window_students(window, return_function) #avoid circular import
Exemple #6
0
    def getStudent(self):
        global g_Database
        rows = g_Database.fetchAll('SELECT * FROM student WHERE personID=' +
                                   str(self.personID))

        if (not len(rows)):
            return None

        student = Student()
        student.read_row(rows[0])
        return student
Exemple #7
0
def updates():
    if request.method == "POST":
        student = Student(IDnum=request.form['idn'],
                          firstName=request.form['fname'],
                          middleName=request.form['mname'],
                          lastName=request.form['lname'],
                          Sex=request.form['sex'],
                          Course=request.form['c'])
        student.update_student()
        return render_template('home.html')
    else:
        return render_template('updatestudent.html')
Exemple #8
0
 def get(self):
     name = self.request.get('name', "")
     if name != "":
         s_id = Student().get_student_id(name_to_search=name)
         classes = ClassRoom().get_students_in_class_by_name(
             id_to_search=s_id)
         print "I AM HERE "
         print s_id
     else:
         people = {}
         people['students'] = Student.query().fetch(10)
         people['instructors'] = Instructor.query().fetch(10)
         self.response.write([people])
Exemple #9
0
def join():
    content = request.get_json(silent=True)
    hashid = cgi.escape(content['hashid'])
    fullName = cgi.escape(content['username'])
    userId = request.cookies.get('remote_userid') if 'remote_userid' in request.cookies else generate_user_id()
    userColor = request.cookies.get('remote_usercolor') if 'remote_usercolor' in request.cookies else generate_color()

    resp = make_response(hashid)

    # Ensure course exists
    courseId = DEFAULT_COURSE_PREFIX + hashid
    course = ndb.Key('Course', courseId).get()

    # Add user to course
    key = courseId + userId
    user = Student.get_or_insert(key, courseId=courseId, studentId=userId, fullName=fullName, color=userColor)
    userInitials = user.initials
    user.put()

    if not user.opentokSessionId:
        opentok_sdk = OpenTok(OPENTOK_API_KEY, OPENTOK_API_SECRET)
        # use tokbox server to route media streams;
        # if you want to use p2p - change media_mode to MediaModes.relayed
        opentok_session = opentok_sdk.create_session(media_mode = MediaModes.routed)
        opentok_token = opentok_sdk.generate_token(opentok_session.session_id)

        user.opentokSessionId = opentok_session.session_id
        user.opentokToken = opentok_token
        user.put()

    teacher = Student.get_teacher_by_course(courseId)

    # Set user cookies (student role)
    auth = json.loads(request.cookies.get('remote_auth')) if 'remote_auth' in request.cookies else {}
    auth[hashid] = {
        'role': 'Student',
        'opentok_api_key': OPENTOK_API_KEY,
        'opentok_session_id': user.opentokSessionId,
        'opentok_token': user.opentokToken,
        'teacher_session_id': teacher.opentokSessionId,
        'teacher_token': teacher.opentokToken
    }
    resp.set_cookie('remote_userfullname', fullName)
    resp.set_cookie('remote_auth', json.dumps(auth))
    resp.set_cookie('remote_userid', userId)
    resp.set_cookie('remote_usercolor', userColor)
    resp.set_cookie('remote_userinitials', userInitials)

    configChanged(courseId, 'config', 'users')
    return resp
 def many_to_many_table_add_data(self):
     """
     多对多表新增
     """
     course_1 = Course(course_name='语文')
     course_2 = Course(course_name='数学')
     course_1.student_list = [
         Student(student_name="张三"),
         Student(student_name="李四"),
     ]
     course_2.student_list = [
         Student(student_name="王二")
     ]
     self.session.add_all([course_1, course_2])
     self.session.commit()
Exemple #11
0
def add_student():
    """adds a new student to the db"""

    fname = request.form.get("fname").strip().capitalize()
    lname = request.form.get("lname").strip().capitalize()
    user_id = session["user_id"]
    birthdate = request.form.get("birthdate")
    phone_number = request.form.get("phone")
    photo = request.form.get("photo")

    if (fname is '') or (lname is '') or (phone_number is '') or (birthdate is
                                                                  ''):
        flash("Please complete all fields of the student profile.",
              category='danger')
        return redirect(f"/user_info/{user_id}")

    student = Student(fname=fname,
                      lname=lname,
                      user_id=user_id,
                      birthdate=birthdate,
                      phone_number=phone_number,
                      photo=photo)
    db.session.add(student)
    db.session.commit()
    return redirect(f"/user_info/{user_id}")
Exemple #12
0
async def getAllCousWS():
    # 载入 Course
    # courses = []

    # 初始化 SQL
    rs = await handler.getAllCouse()
    # 将结果 模型化并返回
    res = []
    if rs is not None:
        for i in rs:
            res.append(Course(**i))

    # 将 course list 转变为 Cws list
    cous = []
    for item in res:
        cous.append(CourseWithStudents(course=item, students=[]))

    # 载入 Students
    for item in cous:
        # 初始化 SQL
        rs = await handler.getStuGrade(item.course.cno)
        # 将结果 模型化并返回
        if rs is not None:
            for i in rs:
                item.students.append(Student(**i))
    # 返回 Cws
    return cous
Exemple #13
0
def add_student(name, year, finished_lab,methods=["GET","POST"]):
	"""
	   
	"""

	if request.method=="GET":
		return render_template('student.html', student=query_by_id(student_id))
	else:
		name=request.form["name"]
		year=request.form["year"]


		save_to_database(name,year)
	return render_template("home.html",
		n=name,
		y=year)	
    


	student_object = Student(
		name=name,
		year=year,
		finished_lab=finished_lab)
	session.add(student_object)
	session.commit()
Exemple #14
0
 def delete(self):
     name = self.request.get('name', "")
     instructor = Instructor().get_instructor_by_name(name_to_search=name)
     student = Student().get_student_by_name(name_to_search=name)
     conf = ""
     print student
     if student == None and instructor == None:
         print("No Object was found. No action taken")
         conf = "No Object was found. No action taken"
     elif student != None:
         print("A Student object was found ")
         conf = Student().delete_student(student)
     elif instructor != None:
         print("An Instructor object was found: " + instructor.key)
         conf = Instructor().delete_instructor(instructor.key)
     self.response.write(conf)
Exemple #15
0
def student_create():
    if request.method == "GET":
        return render_template('student_create.html')
    elif request.method == "POST":
        student = Student(
            first_name=request.form['first_name'],
            last_name=request.form['last_name'],
            alias=request.form['alias'],
            grad_year=request.form['grad_year'],
            email=request.form['email'],
        )
        student.save()
        if "create_and_add" in request.form:
            return render_template('student_create.html')
        elif "create" in request.form:
            return redirect(url_for('student_view', student_pk=student.pk))
Exemple #16
0
def extract_student_fromSIS_fordb():
    """extract student info from SIS and add to StepUp DB table, Student"""
    student = request.args.get('student')
    (firstname, lastname) = student.split(" ")

    #test with this info and then add all other student info for model
    query = """
		SELECT student_number,
		 last_name, 
		 first_name,
		 dob,
		 schoolID  
		FROM students  
		where first_name='""" + (firstname) + """ 'AND last_name='""" + (
        lastname) + """'"""

    query_results = c.execute(query)
    #results = pd.read_sql(query,con)
    df = pd.DataFrame(results)
    #display student name, dob and school id for user to select
    #onclick, add to
    #need to unpack df results to get info to look for student in Student table
    student = Student.query.filter_by(student_number=student_number, dob=dob)

    #need to unpack results to get info to add student
    if not student:
        student = Student(student_number=student_number,
                          stu_fname=first_name,
                          stu_lname=last_name,
                          dob=dob,
                          schoolid=schoolID)
        db.session.add(student)
        db.session.commit()

    return (results.to_json(orient='records'))
Exemple #17
0
def get_current_user():
    """Returns an object of Student or Teacher class, whose credentials are currently saved in session."""
    if session['logged_in']:
        if session['type'] == 'S':
            return Student.get(Student.username == session['username'])
        elif session['type'] == 'T':
            return Teacher.get(Teacher.username == session['username'])
Exemple #18
0
def student_create():
    if request.method == "GET":
        return render_template('student_create.html')
    elif request.method == "POST":
        student = Student(
            first_name=request.form['first_name'],
            last_name=request.form['last_name'],
            alias=request.form['alias'],
            grad_year=request.form['grad_year'],
            email=request.form['email'],
        )
        student.save()
        if "create_and_add" in request.form:
            return render_template('student_create.html')
        elif "create" in request.form:
            return redirect(url_for('student_view', student_pk=student.pk))
def example_data():
    """creates sample data for testing"""

    # Add sample data
    test_user = User(user_name="test_user", password="******", user_id=1)
    db.session.add(test_user)
    test_student = Student(fname="test",
                           lname="student",
                           birthdate=datetime(2000, 9, 7),
                           phone_number="3132589798",
                           user_id=test_user.user_id,
                           student_id=1)
    db.session.add(test_student)
    test_behavior = Behavior(behavior_name="test_behavior",
                             behavior_description="tests stuff",
                             behavior_id=1)
    db.session.add(test_behavior)
    test_intervention = Intervention(intervention_name="test_intervention",
                                     intervention_id=1)
    db.session.add(test_intervention)
    test_progress = Progress(student_id=test_student.student_id,
                             behavior_id=test_behavior.behavior_id,
                             intervention_id=test_intervention.intervention_id,
                             date=datetime(2018, 8, 30),
                             rating="5",
                             comment="test comment",
                             user_id=test_user.user_id)
    db.session.add(test_progress)

    # db.session.add_all([test_user, test_student, test_behavior, test_intervention, test_progress])
    db.session.commit()
Exemple #20
0
def teacher_add_student(class_id):
    """Teacher adds student."""

    fname = request.form["fname"]
    lname = request.form["lname"]

    username = fname[0].lower() + lname.lower()
    password = '******'

    #Create new student object
    new_student = Student(username=username,
                          password=password,
                          fname=fname,
                          lname=lname,
                          class_id=class_id)

    #Add to database and commit
    db.session.add(new_student)
    db.session.commit()

    #Flash registration confirmation, log student in, and redirect to student profile
    flash("Student {} {} added.".format(fname, lname))
    flash("Student username = {}, password = password".format(username))
    flash(
        "Please tell student to change their password the first time they log in."
    )
    return redirect("/classes")
Exemple #21
0
def public_gradebook():
    students = Student.all(order='alias')
    assignments = [a for a in Assignment.all() if a.is_public]
    for student in students:
        # Set the grades following the order specified by assignment_pks
        grades = student.get_grades()

        grades_by_assignment_pk = dict([(g.assignment_pk, g) for g in grades])

        student.points_by_assignment_pk = {}
        for assignment in assignments:
            grade = grades_by_assignment_pk.get(assignment.pk)
            if grade:
                grade.assignment = assignment
            points = grade.points if grade else 0
            student.points_by_assignment_pk[assignment.pk] = points
        student.grades = grades
        student.has_comments = any((grade.comment for grade in grades))

    now = datetime.now()
    return render_template(
        "public_gradebook.html",
        assignments=assignments,
        students=students,
        now=now
    )
Exemple #22
0
def delete():
    try:
        no = int(raw_input("输入学员编号:"))
    except TypeError:
        print '编号类型错误'
        delete()

    try:
        student = Student()
        student.id = no
        result = manager.delete(student)
        if result:
            print '删除[%s]成功' % no
    except KeyError:
        print '编号不存在'
        delete()
Exemple #23
0
def student_delete(student_pk):
    student = Student.get(pk=student_pk)
    if request.method == 'GET':
        return render_template('student_delete.html', student=student)
    if request.method == 'POST':
        student.delete()
        return redirect(url_for('students'))
Exemple #24
0
    def post(self):

        subject=self.get_argument('subject')
        student=self.get_argument('student')

        s=Subject.objects(id=ObjectId(subject)).first()
        if not s:
            return self.write({'err':'课题不存在'})
        if s.applied_to:
            return self.write({'err':'课题已被分配给'+s.applied_to.realname.encode('utf-8')})

        u=Student.objects(username=student).first()
        if not u:
            return self.write({'err':'学生不存在'})
        if u.applied_to:
            return self.write({'err':'学生已被分配'+u.applied_to.name.encode('utf-8')+'课题'})

        # Match Straightly
        s.selected_by=[]
        s.applied_to=u
        u.selected=None
        u.applied_to=s

        s.save()
        u.save()

        self.write({})
def add_student(name, year):
	student_object = Student(
		name=name,
		year=year)
		#finished_lab=finished_lab)
	session.add(student_object)
	session.commit()
Exemple #26
0
def load_students():
    """load fake students into the database"""

    fake = Faker()

    # this is a file of random pics from the random image generator API
    json_string = open("random_pics.json").read()
    pic_dict = json.loads(json_string)

    for student in range(500):
        fname = fake.first_name()
        lname = fake.last_name()
        birthdate = fake.date_of_birth(tzinfo=None,
                                       minimum_age=5,
                                       maximum_age=18)
        user_id = random.randint(1, 20)
        phone_number = '3132589798'
        # this loads a random pic from the file to assign as a student image.
        pic = random.choice(pic_dict['results'])
        photo = pic['picture']['thumbnail']
        del pic
        # photo = '/static/images/cage.jpg'
        student = Student(fname=fname,
                          lname=lname,
                          birthdate=birthdate,
                          phone_number=phone_number,
                          photo=photo,
                          user_id=user_id)
        db.session.add(student)

    db.session.commit()
Exemple #27
0
def student_delete(student_pk):
    student = Student.get(pk=student_pk)
    if request.method == 'GET':
        return render_template('student_delete.html', student=student)
    if request.method == 'POST':
        student.delete()
        return redirect(url_for('students'))
Exemple #28
0
def create():
    if request.method == 'POST':
        content = request.get_json(silent=True)
        fullName = cgi.escape(content['username'])
        className = cgi.escape(content['classname'])

        hashids = Hashids(salt=settings.HASHID_SALT,min_length=6)
        increment()
        count = get_count()
        hashid = hashids.encode(count)

        courseId = DEFAULT_COURSE_PREFIX + hashid
        userId = request.cookies.get('remote_userid') if 'remote_userid' in request.cookies else generate_user_id()
        userColor = request.cookies.get('remote_usercolor') if 'remote_usercolor' in request.cookies else generate_color()

        host = app.config.get('host')
        resp = make_response(hashid)

        # Add course to database
        key = courseId
        course = Course.get_or_insert(key, courseId=courseId, teacherName=fullName)
        course.put()

        # Add teacher to course

        # Create OpenTok session
        opentok_sdk = OpenTok(OPENTOK_API_KEY, OPENTOK_API_SECRET)
        # use tokbox server to route media streams;
        # if you want to use p2p - change media_mode to MediaModes.relayed
        opentok_session = opentok_sdk.create_session(media_mode = MediaModes.routed)
        opentok_token = opentok_sdk.generate_token(opentok_session.session_id)
        
        key = courseId + userId
        user = Student.get_or_insert(key, 
            courseId = courseId,
            studentId = userId,
            fullName = fullName,
            color = userColor,
            role = 'TEACHER',
            opentokSessionId = opentok_session.session_id,
            opentokToken = opentok_token
        )
        user.put()

        # Set user cookies (teacher role)
        auth = json.loads(request.cookies.get('remote_auth')) if 'remote_auth' in request.cookies else {}
        auth[hashid] = {
            'role': 'Instructor',
            'opentok_api_key': OPENTOK_API_KEY,
            'opentok_session_id': user.opentokSessionId,
            'opentok_token': user.opentokToken
        }
        resp.set_cookie('remote_userfullname', fullName)
        resp.set_cookie('remote_auth', json.dumps(auth))
        resp.set_cookie('remote_userid', userId)
        resp.set_cookie('remote_usercolor', userColor)
        #resp.set_cookie('remote_userinitials', userInitials)

        return resp
    return redirect('/main#/create')
 def clear_lesson(self, lesson, write_response=True):
     from model import Student, StudentActivity
     from google.appengine.ext import db
     db.delete(StudentActivity.fetch_all("lesson =", lesson))
     db.delete(Student.fetch_all("lesson =", lesson))
     self.log_out_all_students(lesson, False);
     if write_response:
         self.write_response_plain_text("OK")
def add_new_user(bot, update, user_data):
    '''Логин студента приходит в update message text'''
    new_user = update.message.text
    # TODO: Проверка, что такого пользователя нет
    new_student = Student(username=new_user, role='student')
    user_data['teacher1'].append(
        new_user)  # Добавляем нового ученика в user_data
    db_session.add(new_user)  # Добавляем студента в базу
Exemple #31
0
def add_student_to_db(student_details):
    if student_details:
        row = Student(name=student_details['name'],
                      age=student_details['age'],
                      gender=student_details['gender'])
        session.add(row)
        session.commit()
        return 'Data added succcessfully'
Exemple #32
0
 def get(self):
     file = open('header.html')
     self.response.write(file.read())
     std_all = Student.query()
     values = {"std_info":std_all}
     template = JINJA_ENVIRONMENT.get_template('viewstd.html')        
     html = template.render(values)
     self.response.write(html)
Exemple #33
0
 def post(self):
     class_found = False
     # Grab all the properties that are accepted via the API
     name = self.request.get('name', "")
     role = self.request.get('role', "student")
     class_name = self.request.get('class', "")
     # We first check to see if we are adding an Instructor or Student
     class_room_name = ClassRoom().get_class_by_name(
         name_to_search=class_name)
     if class_room_name != None:
         class_found = True
         class_room = class_room_name.key.get()
     if role == "instructor":
         instructor = Instructor().get_instructor_by_name(
             name_to_search=name)
         if instructor != None:
             print("Instructor Found")
             instructor_key = instructor.key
         else:
             new_instructor = Instructor(name=name)
             instructor = new_instructor.put()
             instructor_key = instructor
         if class_found:
             class_room.instructors.append(instructor_key)
             print("Class Already Exists and adding", instructor_key)
         else:
             class_room = ClassRoom(name=class_name,
                                    instructors=[instructor_key])
     elif role == "student":
         student = Student().get_student_by_name(name_to_search=name)
         if student != None:
             print("Student Found")
         else:
             new_student = Student(name=name)
             student = new_student.put()
             student_key = student
         if class_found:
             class_room.students.append(student_key)
             print("Class " + "Already Exists and adding", student_key,
                   class_room)
         else:
             class_room = ClassRoom(name=class_name, students=[student_key])
             print("This is a new ClassRoom")
     class_room.put()
     self.redirect('/people')
def generateStudent():
    person = generatePerson()

    student = Student()
    student.startYear = datetime.date(random.randint(2012, 2024), 1, 1)
    student.studyCouncelor = random.choice(counselers).teacherID
    student.enrolled = random.choice(studies).studyname
    student.personID = person.personID
    student.insert()

    person.userName = (person.lname + str(student.studentID))
    person.userPass = "******"
    person.update()

    for course in random.sample(courses, 4):
        student.enrollInCourse(course.courseID)

    return student
Exemple #35
0
def add_student(name, year, finished_lab):
    """
	Add a student to the database, given
	their name, year, and whether they have
	finished the lab.
	"""
    student_object = Student(name=name, year=year, finished_lab=finished_lab)
    session.add(student_object)
    session.commit()
Exemple #36
0
async def getAllStu():
    rs = await handler.getAllStudent()
    # 将结果 模型化并返回
    res = []
    if rs is not None:
        for i in rs:
            res.append(Student(**i))

    return res
Exemple #37
0
def assignment_view(assignment_pk):
    assignment = Assignment.get(pk=assignment_pk)
    students = Student.all()
    grades = assignment.get_grades()
    g_by_student_pk = dict([(g.student_pk, g) for g in grades])
    for s in students:
        s.grade = g_by_student_pk.get(s.pk)
    return render_template('assignment_view.html',
                           assignment=assignment,
                           students=students)
Exemple #38
0
def assignment_view(assignment_pk):
    assignment = Assignment.get(pk=assignment_pk)
    students = Student.all()
    grades = assignment.get_grades()
    g_by_student_pk = dict([(g.student_pk, g) for g in grades])
    for s in students:
        s.grade = g_by_student_pk.get(s.pk)
    return render_template(
        'assignment_view.html', assignment=assignment, students=students
    )
    def get(self):
        from model import Student
        import datetime
        import settings

        students = tuple(Student.all().filter("latest_logout_timestamp =", None))
        for student in students:
            if datetime.datetime.now() > student.latest_login_timestamp + settings.STUDENT_SESSION_TIMEOUT:
                student.log_out(True)
                from helpers import log
                log('=> LOGGED OUT {0} FROM LESSON {1} BECAUSE SESSION TIMED OUT'.format(student.nickname,student.lesson.lesson_code))
Exemple #40
0
def add_grade_():
    form = AddGradeForm()
    if form.validate_on_submit():
        try:
            with db.transaction():
                grade = Grade.create(
                    student=Student.get(Student.username == form.student_select.data),
                    subject=Subject.get(Subject.name == form.subject_select.data),
                    teacher=get_current_user(),
                    grade=form.grade.data
                )
        except DatabaseError:
            flash('An error occurred while adding a grade')
        else:
            flash('Grade ' + str(grade.grade) + ' assigned to student ' + str(grade.student))
            return redirect(url_for('groups', group=grade.student.username))
    flash_errors(form)
    students = Student.select()
    subjects = Subject.select()
    return render_template('add_grade.html', students=students, subjects=subjects, form=form)
Exemple #41
0
def student_update(student_pk):
    student = Student.get(pk=student_pk)
    if request.method == 'GET':
        return render_template('student_update.html', student=student)
    elif request.method == 'POST':
        student.first_name = request.form['first_name']
        student.last_name = request.form['last_name']
        student.alias = request.form['alias']
        student.grad_year = request.form['grad_year']
        student.email = request.form['email']
        student.save()
        return redirect(url_for('student_view', student_pk=student_pk))
Exemple #42
0
def assignment_grades_update(assignment_pk):
    assignment = Assignment.get(pk=assignment_pk)
    students = Student.all()
    grades = assignment.get_grades()
    # We decorate the student's with their grades.
    # Ideally, this would be done with a select_related type thing in the
    # model. At the SQL level. TODO
    g_by_student_pk = dict([(grade.student_pk, grade) for grade in grades])
    for s in students:
        s.grade = g_by_student_pk.get(s.pk)

    if request.method == 'GET':
        return render_template(
            "assignment_grades_update.html",
            assignment=assignment,
            students=students
        )

    # TODO: This POSt method seems cumbersome. Can it be fixed?
    if request.method == 'POST':
        for student in students:
            # These keys are first generated in the template as input tag
            # name attributes.
            points_key = "student_{0}_points".format(student.pk)
            comment_key = "student_{0}_comment".format(student.pk)
            try:
                points = request.form[points_key].strip()
                comment = request.form[comment_key].strip()
            except KeyError:
                # This will prevent a 400 status code from being returned if we
                # try to get data from the form about a student that didn't
                # exist when the form was created.
                continue
            try:
                points = int(points.strip())
            except ValueError:
                points = None
            comment = comment.strip()

            if student.grade is None:
                student.grade = Grade(
                    student_pk=student.pk,
                    assignment_pk=assignment.pk,
                    points=points,
                    comment=comment
                )
            else:
                student.grade.points = points
                student.grade.comment = comment
            student.grade.save()
        return redirect(url_for('assignment_view', assignment_pk=assignment_pk))
Exemple #43
0
def gradebook():
    students = Student.all()
    assignments = Assignment.all()
    assignment_pks = [a.pk for a in assignments]
    for student in students:
        # Set the grades following the order specified by assignment_pks
        grades = student.get_grades()
        by_assignment_pk = dict([(g.assignment_pk, g) for g in grades])
        student.grades = [by_assignment_pk.get(pk) for pk in assignment_pks]
    return render_template(
        "gradebook.html",
        assignments=assignments,
        students=students
    )
Exemple #44
0
    def student_details(self):
        self.g_term = cherrypy.session.get('g_term')
        self.g_user = cherrypy.session.get('g_user')
        roles = ['admin']
        self.page_for(roles)

        self.s_data = {}
        errors = {}
        s_data = {}
        if(self.g_term == ""):
            self.g_term = cherrypy.session.get('g_term');
        sql = "SELECT s.*, u.user_name FROM Student s, User u WHERE \
        s.user_id=u.user_id AND s.term='%s'" % (self.g_term)
        db = mysql.DB()
        results = db.do_query(sql)
        for row in results:
            tmp_row = {'user_id':row['user_id'], 'dept':row['dept'],'year':row['year'], 'term':row['term']}
            try:
                student = Student(**tmp_row)
                student.set_name(row['user_name'])
                s_data[student.user_id] = student
            except Invalid, e:
                errors = e.unpack_errors()
 def log_out_all_students(self, lesson=None, write_response=True):
     
     assert self.is_teacher, "Must be logged in as teacher"
     if lesson is None:
         allLessonsForAllTeachers = self.request.get("which_lessons", "0") == "1"
         if allLessonsForAllTeachers:
             assert self.is_teacher and self.person.admin, "Must be admin to logout students from all lessons for all teachers."
     
     from model import Student
     if lesson is not None:
         students = tuple(Student.all().filter("lesson =", lesson))
     elif allLessonsForAllTeachers:
         students = Student.all()
     else:
         students = tuple(Student.all().filter("teacher =", self.person))
         
     for student in students:
         if student.is_logged_in or len(student.client_ids) > 0:
             from helpers import log
             log("Teacher logged out {0} from lesson {1}".format(student.nickname, student.lesson.lesson_code))
             self.log_out_student(student, False)
       
     if write_response:      
         self.write_response_plain_text("OK")
    def get(self):
        self.load_search_party_context(user_type="teacher")

        try:
            if not self.is_teacher:
                raise NotAnAuthenticatedTeacherError()
            
            else:
                lesson = None
                form_item = lambda key:self.request.get(key, "").strip()
                if form_item is not None:
                    lesson_code = form_item("lesson_code")
                    if lesson_code != "":
                        from model import Lesson
                        lesson = Lesson.get_by_key_name(lesson_code)       
                    action = form_item("action")
                if action=="create":
                    self.create_edit_lesson(form_item)
                elif action=="clone":
                    self.clone_lesson(lesson)
                elif action=="edit":
                    self.create_edit_lesson(form_item)
                elif action=="start":
                    self.start_lesson(lesson)  
                elif action=="stop":
                    self.stop_lesson(lesson)
                elif action=="stopall":
                    self.stop_all_lessons()
                elif action=="clear":
                    self.clear_lesson(lesson)
                elif action=="delete":
                    self.delete_lesson(lesson)
                elif action=="deleteall":
                    self.delete_all_lessons()
                elif action=="logoutstudent":
                    from model import Student
                    student_nickname = form_item("student_nickname")
                    student_key = "::".join((student_nickname, lesson_code))
                    student = Student.get_by_key_name(student_key)
                    self.log_out_student(student)
                elif action=="logoutallstudents":
                    self.log_out_all_students(lesson)
                else:
                    self.show_dashboard()

        except NotAnAuthenticatedTeacherError:
            self.redirect_to_teacher_login()
    def load_user(self):
        self.client_id = self.request.get('from', None)
        import client_id_utils
        self.person_type = client_id_utils.person_type_for_client_id(self.client_id)
        assert self.person_type in ("student", "teacher")

        self.person = None
        person_key = client_id_utils.person_key_for_client_id(self.client_id)
        if self.person_type == "teacher":
            from model import Teacher
            self.person = Teacher.get_by_key_name(person_key)
        else:
            from model import Student
            lesson_code = client_id_utils.lesson_code_for_client_id(self.client_id)
            student_key = "::".join((person_key, lesson_code))
            self.person = Student.get_by_key_name(student_key)
            
        if self.person is None:
            from helpers import log
            log("***** ERROR: Person not found for client_id {0}".format(self.client_id))
Exemple #48
0
def student_login_():
    form = StudentLoginForm()
    if form.validate_on_submit():
        try:
            student = Student.get(username=form.username.data)
            # adequate salt is stored in the password itself
            stored_password = student.password.encode('utf-8')
            password_to_check = form.password.data.encode('utf-8')
            password = hashpw(password_to_check, stored_password)
            if password != stored_password:
                raise WrongPassword('Wrong password')
        except WrongPassword:
            flash('Wrong password')
        except Student.DoesNotExist:
            flash('Wrong username or password')
        else:
            authorize_student(student)
            return redirect(url_for('student_profile'))
    flash_errors(form)
    return render_template('student_login.html', form=form)
Exemple #49
0
    def get(self):
        student=self.get_argument('student',"")

        u=Student.objects(username=student).first()
        if not u or not u.resume:
            raise HTTPError(404)

        # Guess browser and write Content-Disposition

        # FIXME: an ugly hack here due to a MongoEngine bug
        #        must use `u.resume.name' for filename while write using `filename'

        # FIXME: filename will break on android with its internal browser
        e=quote(u.resume.name.encode('utf-8')).replace('+','%20')
        ua=self.request.headers['User-Agent'].lower()
        if "msie" in ua:
            cd='filename="%s"'%e
        elif "firefox" in ua:
            cd="filename*=UTF-8''%s"%e
        else:
            cd='filename="%s"'%u.resume.name
        self.set_header('Content-Disposition','attachment;'+cd)
        self.set_header('Content-Type','application/octet-stream')
        self.write(u.resume.read())
Exemple #50
0
	def _send_tab_delimited_report(self, lesson_code, utc_offset):
		import StringIO
		from model import Student, StudentActivity, Lesson
		import helpers
		encoding = "UTF-8"

		lesson = Lesson.get_by_key_name(lesson_code)
		assert lesson is not None

		if lesson is None or lesson.teacher_key != self.teacher_key:
			self.write_response_plain_text("ERROR:  Lesson code appears to be incorrect.")
		else:

			students = Student.fetch_all("lesson =", lesson)
			task_titles = tuple(task_info[0] for task_info in lesson.tasks)
			student_key_to_nickname = dict((s.key().name(), s.nickname) for s in students)
			activities = StudentActivity.fetch_all("lesson =", lesson)

			report_buffer = StringIO.StringIO()
			excel_writer = UnicodeWriter(report_buffer, "excel-tab", "utf8")

			headers = (
#					"Lesson_Code",
					"Timestamp",
					"Student",
					"Task_Number",
					"Task_Name",
					"Activity_Type",
					"Query",
					"Link_URL",
					"Link_Title",
					"Is_Helpful",
					"Answer_Text",
					"Answer_Explanation"
			)
			excel_writer.writerow(headers)

			for activity in activities:
				student_key = activity.student_key.name()
				student_nickname = student_key_to_nickname[student_key]
				timestamp = (activity.timestamp - utc_offset).strftime("%m/%d/%Y %H:%M:%S")
				task_idx = activity.task_idx
				task_title = task_titles[task_idx]
				task_num = task_idx + 1
				line_parts = (
#						lesson_code,
						timestamp,
						student_nickname,
						task_num,
						task_title,
						activity.activity_type,
						activity.search,
						activity.link,
						activity.link_title,
						activity.is_helpful,
						activity.answer_text,
						activity.answer_explanation
				)
#				line_parts = tuple(unicode(p).encode("utf8") for p in line_parts)
				excel_writer.writerow(line_parts)
			report_text = report_buffer.getvalue()
			report_buffer.close()

			content_type = "text/tab-separated-values"
			filename = "search_party_lesson_%s_activity_as_of_%s.txt"%(lesson_code, helpers.timestamp())
			self.write_response_as_file(encoded_content=report_text, content_type=content_type, filename=filename, encoding=encoding)
def enrollNewStudent(params, reg, id):
    """ Generate a new 9th grade Freshman """
    # generate cheasy names and student data
    skippable = params["skippable"]
    age = 14 if random.random() < params["lowAge"] else 15
    lname = random.choice(randomNames) + ("s" if random.random() > 0.25 else "")
    s = Student(id, random.choice(randomNames), lname, age, 9)
    s.beginNewYear()
    s.enroll(reg.getCourse(name="PE"))
    enrolledCount = 1
    if random.random() < params["band"]:
        s.enroll(reg.getCourse(name="Band"))
        enrolledCount += 1
    req, opts = suggestClasses(reg, s, ignoreElectives=False)
    honorsChance = params["honors"]
    def asHonors(c):
        nonlocal honorsChance
        res = c.hasHonors and random.random() < honorsChance
        if res:
            honorsChance *= 1 + params["honorsCompound"]
        return res
    while enrolledCount < params["maxCourses"] and len(req) > 0:
        selected = req.pop()
        if selected.name in skippable:
            honorsResult = random.random() < honorsChance
            honorsChance *= (1 + params["honorsCompound"])**honorsResult
            if honorsResult:
                # give student credit for the course
                s.passed(selected, True, overrideHonors=True)
                selected = next(i for i in reg.getCoursesRequiring(selected)
                                if i.canEnroll(s))
                # enroll them in the next course
                s.enroll(selected, random.random() >= params["honorsFallOut"])
                enrolledCount += 1
                continue
        honorsResult = asHonors(selected)
        s.enroll(selected, honorsResult)
        enrolledCount += 1
    while enrolledCount < params["maxCourses"] and len(opts) > 0:
        selected = opts.pop(randint(0, len(opts)-1))
        # electives probably won't have honors versions, but just in case
        s.enroll(selected, asHonors(selected))
        enrolledCount += 1
    return s
    def _attempt_to_identify_as_student(self):
        from model import Student
        from helpers import log

        # Initialize student
        # We still store changes to student record only, if any, but we don't want to store
        # the record needlessly, since that consumes billable resources.
        student = None
        student_is_dirty = False

        # There are two ways to identify a student: nickname + lesson code sent via CGI,
        # or the session ID.  We will try them in that order.

        # Get CGI form values
        lesson_code = self.request.get("lesson_code", None)
        student_nickname = self.request.get("student_nickname", None)
        if lesson_code is not None and student_nickname is not None:
            # 1. Fetch student by nickname+lesson
            student_nickname = self.htmlunquote(student_nickname)
            key_name = Student.make_key_name(student_nickname=student_nickname, lesson_code=lesson_code)
            student = Student.get_by_key_name(key_name)
            log("=> SEARCHING BY NAME AND LESSON CODE: {0}, {1}, {2}".format(student_nickname, lesson_code, key_name))

            if student is not None and self.session.sid != student.session_sid:
                if student.is_logged_in:
                    # Prevent login if student already logged in to another session
                    # GAE limits # of channels so we don't want to allow too many student windows
                    from all_exceptions import StudentLoginException

                    raise StudentLoginException(
                        "Please choose another name.  Someone is already logged in as %s."
                        % (student_nickname.encode("ascii", "xmlcharrefreplace")),
                        "Session ID doesn't match.",
                        student.session_sid,
                        self.session.sid,
                        student.latest_login_timestamp,
                        student.latest_logout_timestamp,
                    )

        #                else:
        #                # Need to update session id if student was logged into another browser previously (and then logged out)
        #                    student.session_sid = self.session.sid
        #                    student_is_dirty = True

        else:
            # 2. Fetch student by session id
            student = Student.all().filter("session_sid =", self.session.sid).get()
            log("=> SEARCHING FOR STUDENT BY SESSION ID {0}".format(self.session.sid))

            if student is not None and not student.is_logged_in:
                # Passively log student in again.
                # At some point this student logged into this browser but logged out passively.
                from datetime import datetime

                student.latest_login_timestamp = datetime.now()
                student.latest_logout_timestamp = None
                student_is_dirty = True
                log("=> PASSIVE STUDENT LOGIN AFTER PASSIVE LOGOUT")

        if student_is_dirty:
            # Store changes to student record, if any.
            student.put()

        if student is not None and not student.is_logged_in:
            log("=> STUDENT IS **NOT** LOGGED IN")

        return student
    def post(self):
        import json
        from model import Student, Lesson
        from all_exceptions import StudentLoginException
        from datetime import datetime
        from helpers import log

        try:
            self.load_search_party_context(user_type="student")

            # Get CGI form fields.
            lesson_code = self.request.get('lesson_code')
            student_nickname = self.request.get('student_nickname')
            ext = int(self.request.get('ext', 0))

            # Normalize whitespace in student name.
            # Replace any string of >=1 whitespace with a single space (equivalent to s/\s+/ /g).
            student_nickname = " ".join(student_nickname.split())

            if not lesson_code:
            # No lesson code
                raise StudentLoginException("Please enter a lesson code.",
                        "lesson_code==%r"%lesson_code)
                
            # If no student nickname, generate an anonymous one
            anonymous = False
            if not student_nickname:
                import random, string
                alphabet = string.letters + string.digits

                anonymous_student = None
                for i in range(8):
                    random_nickname = "".join(random.choice(alphabet) for i in range(10))
                    key_name = Student.make_key_name(student_nickname=random_nickname, lesson_code=lesson_code)
                    anonymous_student = Student.get_by_key_name(key_name)
                    if anonymous_student is None:
                        student_nickname = random_nickname
                        anonymous = True
                        break
    
            if anonymous and not student_nickname:
            # No student name
                raise StudentLoginException("Could not login as anonymous student.",
                        "student_nickname==%r"%student_nickname)

#            if not lesson_code and not student_nickname:
#            # Blank form
#                raise StudentLoginException("Please enter a lesson code and a student name.",
#                        "lesson_code==%r, student_nickname==%r"%(lesson_code, student_nickname))
#            elif not lesson_code:
#            # No lesson code
#                raise StudentLoginException("Please enter a lesson code.",
#                        "lesson_code==%r"%lesson_code)
#            elif not student_nickname:
#            # No student name
#                raise StudentLoginException("Please enter a student name.",
#                        "student_nickname==%r"%student_nickname)

            lesson = Lesson.get_by_key_name(lesson_code)
            # Retrieve lesson from DB
            # - If lesson does not exist, this will return None.
            # - If lesson existed but is disabled, it will return the lesson, but lesson.is_active will be False.
            # - If lesson existed but was deleted (hidden), it will return the lesson, but lesson.is_deleted will be True.
            #   (Deleting lessons is done lazily.  Actually, they are merely hidden from the teacher's view.)

            if lesson is None or lesson.is_deleted:
            # Lesson does not exist or was deleted (hidden).
                raise StudentLoginException("Please check the lesson code.",
                        "lesson retrieved from datastore with lesson_code %r is None"%lesson_code)
            elif not lesson.is_active:
            # Lesson has been disabled by teacher.  Students are not allowed to work on it anymore.
                raise StudentLoginException("This lesson is finished.  You cannot work on it now.",
                        "lesson_code %r has is_active=False"%lesson_code)
            
            # Fetch student from DB.
            # - Might return None if nobody has ever logged in with this nickname+lesson combination.
            key_name = Student.make_key_name(student_nickname=student_nickname, lesson_code=lesson_code)
            student = Student.get_by_key_name(key_name)
            login_timestamp = datetime.now()

            if student is not None:
            # Found the student.
                student.session_sid=self.session.sid
                student.latest_login_timestamp = login_timestamp
                student.latest_logout_timestamp = None
                if not student.first_login_timestamp:
                    student.first_login_timestamp = login_timestamp

            else:                
                student = Student(
                    key_name=key_name,
                    nickname=student_nickname,
                    teacher=lesson.teacher_key,
                    lesson=lesson,
                    task_idx=self.INITIAL_TASK_IDX,
                    first_login_timestamp=login_timestamp,
                    latest_login_timestamp=login_timestamp,
                    latest_logout_timestamp=None,
                    session_sid=self.session.sid,
                    anonymous=anonymous,
                    client_ids=[]
                )

            assert student.session_sid is not None
            student.put()
            self.set_person(student)
            displayName = "Anonymous" if self.is_student and self.person.anonymous else self.person.nickname
            self.session['msg'] = "Student logged in:  Hello " + displayName
            self.response.headers.add_header('Content-Type', 'application/json', charset='utf-8')
            self.response.out.write(json.dumps({"status":"logged_in", "ext":ext}))
            log( "=> LOGIN SUCCESS" )

        except StudentLoginException, e:
            e.log()
            self.set_person(None)
            msg = e.args[0]
            self.session['msg'] = msg
            self.response.headers.add_header('Content-Type', 'application/json', charset='utf-8')
            self.response.out.write(json.dumps({"status":"logged_out", "error":msg}))
            log( "=> LOGIN FAILURE:  %s"%msg )
    def make_student_structure(self, lesson, student=None):
        # If student is None, then this will return info for all students who
        # worked on this lesson.

        from model import Student, StudentActivity

        if student is not None:
            students = (student,)
            filter_key = "student ="
            filter_value = student
        else:
            students = tuple( Student.all().filter("lesson =", lesson) )  # PERFORMANCE: Generator might be inefficient
            filter_key = "lesson ="
            filter_value = lesson

        student_structure = {}

        if len(students) > 0:
            num_tasks = len(lesson.tasks)

            for student in students:
                tasks_info = [{"searches":[], "answer":{"text":"", "explanation":""}, "history":[]} for _ in range(num_tasks)]
                student_structure[student.nickname] = {
                    "task_idx"  : student.task_idx,
                    "logged_in" : student.is_logged_in,
                    "tasks"     : tasks_info
                }

            # Policy:  Don't report same (query,student,task_idx) more than once.
            # This dictionary enforces that.
            searches_dict = {}
            
            # (student_nickname,task_idx,link_url) -> ([link_info,...], is_helpful)
            link_infos_and_ratings = {}  
            
            activities = StudentActivity.fetch_all(filter_key, filter_value)

            for activity in activities:
                student_nickname = activity.student.nickname
                task_idx = activity.task_idx

                activity_type = activity.activity_type
                if activity_type in (StudentActivity.ACTIVITY_TYPE_LINK,
                                     StudentActivity.ACTIVITY_TYPE_LINK_RATING,
                                     StudentActivity.ACTIVITY_TYPE_SEARCH):

                    link_url = activity.link
                    key = (student_nickname,task_idx,link_url)
                    link_infos_and_rating = link_infos_and_ratings.setdefault(key, [[],None])
                    if activity_type in (StudentActivity.ACTIVITY_TYPE_LINK, StudentActivity.ACTIVITY_TYPE_SEARCH):
                        query = activity.search
                        search_key = (student_nickname, task_idx, query)
                        try:
                            search_info = searches_dict[search_key]
                        except KeyError:
                            search_info = {"query":query, "links_followed":[]}
                            student_structure[student_nickname]["tasks"][task_idx]["searches"].append(search_info)
                            searches_dict[search_key] = search_info

                    if activity_type==StudentActivity.ACTIVITY_TYPE_LINK:
                        link_title = activity.link_title
                        link_info = {"url":link_url, "title":link_title, "is_helpful":None}
                        search_info["links_followed"].append(link_info)
                        link_infos_and_rating[0].append(link_info)

                    elif activity_type==StudentActivity.ACTIVITY_TYPE_LINK_RATING:
                        link_infos_and_rating[1] = activity.is_helpful

                elif activity_type==StudentActivity.ACTIVITY_TYPE_ANSWER:
                    # This will end up with the most recent answer because it is in ascending time order, so
                    # later answers will overwrite the older ones.
                    answer_info = student_structure[student_nickname]["tasks"][task_idx]["answer"]
                    answer_info["text"] = activity.answer_text
                    answer_info["explanation"] = activity.answer_explanation

                student_structure[student_nickname]["tasks"][task_idx]["history"].append(activity)
               
            for k,v in link_infos_and_ratings.items():
                (student_nickname,task_idx,link_url) = k
                link_infos, is_helpful = v
                for link_info in link_infos:
                    link_info["is_helpful"] = is_helpful

        return student_structure
Exemple #55
0
def student_view(student_pk):
    student = Student.get(pk=student_pk)
    return render_template("student_view.html", student=student)
Exemple #56
0
def students():
    students = Student.all()
    return render_template('student_list.html', students=students)
Exemple #57
0
def groups_():
    student_groups = Student.select(Student.group).distinct().order_by(Student.group.asc())
    return render_template('groups.html', student_groups=student_groups)
Exemple #58
0
def group_():
    group_number = get_current_user().group
    students = Student.select().where(Student.group == group_number)
    return render_template('group.html', group=group_number, students=students)
Exemple #59
0
def group_foreign_(group_number):
    students = Student.select().where(Student.group == group_number)
    return render_template('group.html', group=group_number, students=students)
Exemple #60
0
def student_profile_foreign_(username):
    student = Student.get(Student.username == username)
    subjects = Subject.select()
    grades = Grade.select().where(Grade.student == student)
    return render_template('student_profile.html', student=student, subjects=subjects, grades=grades)