def createClass(zname, zinstructors):
from app.models import Class, User
instructors = []
for i in zinstructors:
try:
instructor = User.objects.get(email = i)
except Exception as e:
# STUPID hacky but for some reason can't figure out where the
# DoesNotExist and MultipleObjectsReturned are for the life of me.
# If you can fix this I will be very very thankful.
if repr(e).startswith("DoesNotExist("):
print >> sys.stderr, "createClass:", i, " does not exist."
return False
else:
raise
if instructor.accountType != User.accountTypes.instructor:
print >> sys.stderr, "createClass:", i, "is not an instructor"
return False
instructors.append(instructor)
newClass = Class(name = zname)
newClass.save()
for i in instructors:
i.classes.append(newClass)
i.save()
print "createClass: Succesfully created class"
return True
def createClass(zname, zinstructors):
from app.models import Class, User
instructors = []
for i in zinstructors:
try:
instructor = User.objects.get(email=i)
except Exception as e:
# STUPID hacky but for some reason can't figure out where the
# DoesNotExist and MultipleObjectsReturned are for the life of me.
# If you can fix this I will be very very thankful.
if repr(e).startswith("DoesNotExist("):
print >> sys.stderr, "createClass:", i, " does not exist."
return False
else:
raise
if instructor.accountType != User.accountTypes.instructor:
print >> sys.stderr, "createClass:", i, "is not an instructor"
return False
instructors.append(instructor)
newClass = Class(name=zname)
newClass.save()
for i in instructors:
i.classes.append(newClass)
i.save()
print "createClass: Succesfully created class"
return True
def test_get_all_students_in_class(self):
u = User(username='******', email='*****@*****.**', role="Teacher")
newClass = Class("test", "test", 2019, "French", "Practice")
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, newClass.class_id)
db.session.add(student_class)
db.session.commit()
students_in_class = newClass.get_all_students_in_class().all()
self.assertEqual(len(students_in_class), 1)
self.assertEqual(students_in_class[0], u)
def register():
if current_user.is_authenticated:
return redirect(url_for('index'))
form = RegisterClass()
if form.validate_on_submit():
class_ = Class(class_name=form.className.data, class_token=form.classToken.data,
class_teacher=form.classTeacher.data)
class_.set_password(form.classPassword.data)
db.session.add(class_)
db.session.commit()
return redirect(url_for('login'))
return render_template('register.html', form=form)
def new_task(class_id):
form = TaskForm()
cls = Class(ObjectId(class_id))
cls.flask_validate()
if form.validate_on_submit():
date = form.date.data
time = form.time.data
dt = datetime.combine(date, time
or datetime.min.time()) if date else None
created_task = Task.create(form.name.data,
class_=cls,
date=dt,
description=form.description.data,
category=form.category.data)
return redirect(url_for('pages.view_class', class_id=class_id))
return render_template('new_task.html', form=form)
def test_get_completed_courses_in_class(self):
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
score = 50
activity_id = 2
activity_result = Activity_Results(activity_id=activity_id,
score=score,
class_id=u.current_class)
db.session.add(activity_result)
db.session.commit()
student_activity = Student_Activity(
activity_instance_id=activity_result.activity_instance_id,
student_id=u.user_id)
db.session.add(student_activity)
db.session.commit()
level = Student_Class_Level(user_id=u.user_id,
class_id=u.current_class,
level=1)
db.session.add(level)
db.session.commit()
u.freeze_stats()
completed_course = u.get_completed_courses_in_class(u.current_class) #
self.assertEqual(len(completed_course), 1)
def test_get_doodles(self):
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
doodle = Doodles(foreign_answer="test",
foreign_guess="test",
location="location")
db.session.add(doodle)
db.session.commit()
student_doodle = Student_Doodles(user_id=u.user_id,
doodle_id=doodle.doodle_id)
class_doodle = Class_Doodles(class_id=u.current_class,
doodle_id=doodle.doodle_id)
db.session.add_all([student_doodle, class_doodle])
db.session.commit()
doodles = u.get_doodles().all()
self.assertTrue(len(doodles) == 1)
def create_class():
user = g.current_user
# admin_id = Role.query.filter_by(name='Administrator').first().id
# if user.role_id != admin_id:
# return jsonify({
# "status":408
# })
data = request.form
name = data.get('name')
tmp = Class.query.filter_by(name=name).first()
if tmp is not None:
return jsonify({
"status":400
})
cls = Class.from_form(data)
db.session.add(cls)
db.session.commit()
cls.add_user(user.id)
result = client.group_create(
user_id_list=[user.id],
group_id=cls.id,
group_name=cls.name
)
if result[u'code'] == 200:
return jsonify({
'status': 200,
'id': cls.id
})
else:
return jsonify({
'status': result[u'code']
})
def classes(classes_creat):
cla_number = [cla_number for cla_number in classes_creat.col_values(0)]
cla_name = [cla_name for cla_name in classes_creat.col_values(1)]
cla_grades = [
xlrd.xldate_as_tuple(cla_grades, workbook.datemode)
for cla_grades in classes_creat.col_values(2)
]
cla_grade = [
date(*cla_grade[:3]).strftime('%Y-%m-%d')
for cla_grade in cla_grades
]
cla_headmaster = [
cla_headmaster for cla_headmaster in classes_creat.col_values(3)
]
classes_list = zip(cla_number, cla_name, cla_grade, cla_headmaster)
for clas in classes_list:
Class.create_cla(*clas)
def test_get_user_language(self):
u = User(username='******', email='*****@*****.**', role="Teacher")
newClass = Class("test", "test", 2019, "French", "Practice")
u.current_class = "test"
db.session.add_all([u, newClass])
db.session.commit()
langauge = u.get_student_language()
self.assertEqual(langauge, "French")
def edit_class(class_id):
cls = Class(ObjectId(class_id))
cls.flask_validate(edit=True)
form = ClassForm(obj=cls.to_struct())
if form.validate_on_submit():
cls.name = form.name.data
cls.description = form.description.data
return redirect(url_for('pages.view_class',
class_id=str(cls.get_id())))
return render_template('edit_class.html', form=form, cls=cls)
def new_class():
form = ClassForm()
if form.validate_on_submit():
name = form.name.data
description = form.description.data
created_class = Class.create(name,
current_user,
description=description)
return redirect(url_for('pages.home'))
return render_template('new_class.html', form=form)
def test_get_student_activities_and_stats(self):
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
score = 50
activity_id = 2
activity_result = Activity_Results(activity_id=activity_id,
score=score,
class_id=u.current_class)
db.session.add(activity_result)
db.session.commit()
student_activity = Student_Activity(
activity_instance_id=activity_result.activity_instance_id,
student_id=u.user_id)
db.session.add(student_activity)
db.session.commit()
activities = u.get_activities("test").all()
avg_score = u.get_student_overall_average_score(activities)
ranked_activities, pieData = u.rank_activities_for_student(activities)
highest, lowest, barData = u.get_high_low_average_activities(
activities)
studentsInClass = newClass.get_all_students_in_class().all()
students_with_averages, class_average = newClass.get_students_with_average(
studentsInClass)
rank = newClass.get_student_rank_in_class(students_with_averages, u)
self.assertEqual(avg_score, 50)
self.assertEqual(len(ranked_activities), 1)
self.assertEqual(highest, lowest)
self.assertEqual(len(studentsInClass), 1)
self.assertEqual(class_average, 50)
self.assertEqual(rank[0], 1)
self.assertEqual(rank[1], 1)
self.assertEqual(len(rank[2]), 1)
self.assertEqual(len(activities), 1)
def test_get_misspelled_words(self):
u = User(username='******',
email='*****@*****.**',
role="Student",
current_class="test")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
misspelled_word = Misspelled_Word(class_id=u.current_class,
user_id=u.user_id,
word="Hello",
translated_word="Bonjour")
db.session.add(misspelled_word)
db.session.commit()
user_mispelled = u.get_misspelled_words(u.current_class).all()
class_mispelled = newClass.get_misspelled_words().all()
self.assertEqual(len(user_mispelled), 1)
self.assertEqual(len(class_mispelled), 1)
def import_data(self):
timetable_list = []
classes = pd.read_csv(
os.path.join(self.raw_data_directory, 'classes.csv'))
for i in range(1, 5):
timetable = pd.read_csv(
os.path.join(self.raw_data_directory,
'timetable{}.csv'.format(i)))
timeslots = []
mod_code_list = []
for index, row in timetable.iterrows():
day = row['day']
start_time = row['start_time'].split(':')
end_time = row['end_time'].split(':')
module_code = row['module_code']
class_ = classes.loc[classes['mod_code'] == module_code]
class_row = class_.iloc[0]
#print(class_row)
name = class_row['name']
number_taking = int(class_row['number_taking'])
class_id = int(class_row['id'])
class_object = Class(mod_name=name,
mod_code=module_code,
number_taking=number_taking)
start_time_hour = int(start_time[0])
end_time_hour = int(end_time[0])
st_time = datetime(year=2017,
day=1,
month=1,
hour=start_time_hour)
end_time = datetime(year=2017,
day=1,
month=1,
hour=end_time_hour)
timeslot = Timeslot(day=day,
start_time=st_time,
end_time=end_time,
module_code=module_code,
class_=class_object)
timeslots.append(timeslot)
#timetable = Timetable(id=id, timeslots = timeslots)
timetable = Timetable(timeslots=timeslots)
timetable_list.append(timetable)
self.objects = timetable_list
def test_get_students_new_vocab(self):
u = User(username='******',
email='*****@*****.**',
role="Student",
current_class="test")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
newVocab = Student_Vocab(english="hello",
translation="bonjour",
user_id=u.user_id,
class_id=u.current_class,
activity_id=14)
db.session.add(newVocab)
db.session.commit()
vocab = u.get_students_new_vocab(u.current_class).all()
class_vocab = newClass.get_class_new_vocab()
self.assertEqual(len(vocab), 1)
self.assertEqual(len(class_vocab), 1)
def test_user_remove_class(self):
"""测试用户被移除班级的功能"""
u = User()
c = Class()
c.join_user(u)
c.remove_user(u)
self.assertNotIn(u, c.users.all())
def test_get_activity_scores_in_class(self):
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
score = 50
activity_id = 2
activity_result = Activity_Results(activity_id=activity_id,
score=score,
class_id=u.current_class)
db.session.add(activity_result)
db.session.commit()
student_activity = Student_Activity(
activity_instance_id=activity_result.activity_instance_id,
student_id=u.user_id)
db.session.add(student_activity)
db.session.commit()
activities = newClass.get_activity_scores_in_class().all()
students = newClass.get_all_students_in_class().all()
language = newClass.get_language()
games_class = newClass.get_games_played_by_class(students)
self.assertEqual(len(games_class), 2)
self.assertEqual("French", language)
self.assertEqual(len(activities), 1)
self.assertEqual(activities[0], activity_result)
def classes():
form = ClassForm()
if form.validate_on_submit():
name = form.name.data
subject = form.subject.data
student_id = form.student_id.data
db.session.add(Class(name=name, subject=subject, student_id=int(student_id)))
db.session.commit()
c = Class.query.all()
return render_template('class.html', Title='Classes', form=form, classes=c)
def add_class():
if request.method == 'POST':
cls_name = request.form['cls_name']
cls_fee = request.form['cls_fee']
admin_id = current_user.id
db.session.add(
Class(cls_name=cls_name, cls_fee=cls_fee, admin_id=admin_id))
db.session.commit()
flash('{} is successfully added'.format(cls_name))
return redirect(url_for('list_of_class'))
return render_template('administrator/add_class.html',
title='Add New Class',
u_class=None)
def test_parent_creation(self):
create_user('parent_1', 'Вася', 'Пупкин', 'Алексеевич', None)
class10A = Class(form=10, liter='A', user=User.query.filter_by(id=1).first())
pupil = Role(name='Pupil')
db.session.add(class10A, pupil)
db.session.commit()
create_user('pupil_1', 'Вася', 'Пупкин', 'Алексеевич', pupil)
connect_pupil_info(User.query.filter_by(id=2).first(), class10A)
create_parent(User.query.filter_by(id=1).first(),
Pupil_info.query.filter_by(id=1).first())
assert Pupil_info.query.filter_by(id=1).first().parent.id == 1
assert Parent.query.filter_by(user_id=1).first().pupils[0] == \
Pupil_info.query.filter_by(id=1).first()
def test_get_incorrect_letters(self):
u = User(username='******',
email='*****@*****.**',
role="Student",
current_class="test")
newClass = Class("test", "test", 2019, "French", "Class")
a = Activity()
a.populate_table()
db.session.add_all([u, newClass])
db.session.commit()
for guessChar, wordChar in zip("hillo", "hello"):
if guessChar != wordChar:
incorrect_character = Incorrect_Character(
class_id=u.current_class,
user_id=u.user_id,
incorrect_letter=guessChar,
correct_letter=wordChar)
db.session.add(incorrect_character)
db.session.commit()
incorrect = u.get_incorrect_letters(u.current_class).all()
self.assertEqual(len(incorrect), 1)
self.assertEqual(
len(newClass.get_incorrect_letters_by_students().all()), 1)
def classes(training_id):
if 'username' in session:
username = session['username']
if session['role'] == 1 or session[
'role'] == 2: ##COMPROBAR SI ES ADMIN PARA ENTRAR
training = Training.query.get(training_id)
form = ClassForm()
if request.method == 'POST':
new_class = Class(date=form.date.data,
topics=form.topics.data,
topicsNext=form.topicsNext.data,
comments=form.comments.data)
if len(training.classes.all()) == 0:
new_class.number = 1
else:
new_class.number = db.session.query(func.max(
Class.number)).filter(
Class.training_id == training_id).first()[0] + 1
new_class.training = training
if not new_class.date or not new_class.topics or not new_class.topicsNext:
flash('Debes completar todos los campos.', 'error')
return redirect((url_for('classes',
training_id=training.id)))
else:
db.session.add(new_class)
db.session.commit()
flash('Clase agregada correctamente', 'success')
#return redirect((url_for('classes', training_id=training.id)))
return render_template('classes.html',
title='Seguimiento',
classes=training.classes,
training_id=training_id,
finalizada=training.finalizada,
form=form)
else:
return redirect(url_for('forbidden'))
return redirect(url_for('login'))
def test_generate_class(self):
fake_class = Class(class_name="LAST", class_token="LAST")
fake_class.set_password("password")
db.session.add(fake_class)
names = self.get_name()
for i in range(0, 50):
s = Student(student_name=names[i])
db.session.add(s)
fake_class.insert(s)
db.session.commit()
length = len(fake_class.get_student().all())
self.assertEqual(length, 50)
self.assertEqual(self.generate_timetable(), 1000)
def test_insert(self): s = Student(student_name='lalala') c = Class(class_name='test2') db.session.add(s) db.session.add(c) self.assertEqual(c.students.all(), []) c.insert(s) db.session.commit() self.assertTrue(c.is_inserting(s)) self.assertEqual(c.students.count(), 1) self.assertEqual(c.students.first().student_name, 'lalala') c.uninsert(s) db.session.commit() self.assertFalse(c.is_inserting(s)) self.assertEqual(c.students.count(), 0)
def test_get_user_practice_areas(self):
u = User(username='******', email='*****@*****.**', role="Teacher")
newClass = Class("test", "test", 2019, "French", "Practice")
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, newClass.class_id)
db.session.add(student_class)
db.session.commit()
teacher_practice_areas = u.get_user_practice_areas().all()
u = User(username='******',
email='*****@*****.**',
role="Student")
newClass = Class("test1", "test", 2019, "French", "Practice")
db.session.add_all([u, newClass])
db.session.commit()
student_class = Student_Class(u.user_id, "test1")
u.current_class = "test"
db.session.add(student_class)
db.session.commit()
student_practice_areas = u.get_user_practice_areas().all()
self.assertGreater(len(student_practice_areas), 0)
self.assertGreater(len(teacher_practice_areas), 0)
self.assertEqual(student_practice_areas[0].class_id, "test1")
self.assertEqual(teacher_practice_areas[0].class_id, "test")
def post(self):
json_data = request.get_json()
if not json_data:
raise RequestException("No input data", 400)
try:
data = class_schema.load(json_data)
except ValidationError as err:
raise RequestException("Invalid input data", 400, err.messages)
_class = Class.create(**data)
result = class_schema.dump(_class)
response = jsonify(
{APIConst.MESSAGE: 'created new class',
APIConst.DATA: result})
return response
def import_data(self):
classes = pd.read_csv(os.path.join(self.raw_data_directory, 'classes.csv'))
class_objects = []
for index, row in classes.iterrows():
id = row['id']
mod_code = row['mod_code']
name = row['name']
number_taking = (row['number_taking'])
num_taking = int(number_taking)
module = Class(id=id, mod_code=mod_code,mod_name=name,number_taking=num_taking)
class_objects.append(module)
self.objects = class_objects
def add_class():
form = AddClassForm()
if form.validate_on_submit():
if Class.query.filter_by(class_name=form.name.data).first():
flash(u"错误：班级已存在")
else:
_class = Class(
class_name=form.name.data,
class_desc=form.desc.data,
belong_dis=form.dis.data
)
db.session.add(_class)
db.session.commit()
flash(u"添加成功")
return redirect(url_for('auth.add_class'))
return render_template('auth/add_class.html', form=form)
def patch(self, id):
_class = self.get_resource_with_ids(Class, id)
json_data = request.get_json()
try:
data = class_patch_schema.load(json_data, partial=True)
except ValidationError as err:
raise RequestException("Invalid input data", 400, err.messages)
try:
_class.update(**data)
except Exception as err:
raise RequestException(
payload={APIConst.INPUT: json_data}) from err
result = class_schema.dump(Class.get_with_id(_class.id))
response = jsonify({APIConst.MESSAGE: 'updated class {}'.format(id),
APIConst.DATA: result})
return response
def generate_class(names):
fake_class = Class(class_name="TEST",
class_token="TEST",
class_teacher="Hello")
fake_class.set_password("password")
db.session.add(fake_class)
for i in range(0, 50):
student_number = '00' + str(i)
s = Student(student_name=names[i], student_number=student_number)
db.session.add(s)
fake_class.insert(s)
db.session.commit()
def test_get_students(self): s1 = Student(student_name="s_1") s2 = Student(student_name="s_2") s3 = Student(student_name="s_3") s4 = Student(student_name="s_4") db.session.add_all([s1, s2, s3, s4]) c = Class(class_name="test3") db.session.add(c) c.insert(s1) c.insert(s2) c.insert(s3) c.insert(s4) db.session.commit() f1 = c.get_student().all() self.assertEqual(f1, [s1, s2, s3, s4])
