def create_class():
class_name = request.form.get('class_name')
deadline = request.form.get('deadline')
groups = json.loads(request.form.get('groupJSON'))
class_create = Class(class_name, deadline)
print(class_name, deadline, groups)
db.session.add(class_create)
db.session.commit()
for i, g in enumerate(groups):
group_password = ''.join(
random.choice(string.ascii_uppercase + string.digits)
for _ in range(8))
password_hash = bcrypt.generate_password_hash(group_password)
group = Group(username=g['username'],
password_hash=password_hash,
members=g['members'],
class_id=class_create.id)
groups[i]['password'] = group_password
db.session.add(group)
db.session.commit()
mailer.send_passwords(groups)
response = dict()
response['success'] = True
response['message'] = "Successfully created class " + class_name + "!"
return jsonify(response)
def put_class(name, school_id):
group = Class(name=name, school_id=school_id)
db.session.add(group)
db.session.commit()
return jsonify(group.json()) if group else ''
return jsonify(school.json()) if school else ''
def classRegistration():
if(session['logged_in']): #if user not loggin
if(request.method == 'GET'):
return render_template('classRegistration.html')
elif(request.method == 'POST'):
try:
t_id = request.json['t_id']
class_id = request.json['class_id']
grade = request.json['grade']
subject = request.json['subject']
teacher = DataPipelineObj.get_teacher_details(t_id)
if(teacher): #if there is a teacher with that id
newClass = Class(class_id, grade, subject)
new_teacher_class = Teacher_class(t_id, class_id)
DataPipelineObj.insert_data(newClass) #add new class etails into the database
DataPipelineObj.insert_data(new_teacher_class)
return jsonify({'status':"Class successfully registered"}) #update teache_class table
else: #if there is not a teacher with that id
return jsonify({'status':"There is no such teacher id"})
except:
return jsonify({'status':"There is something wrong. Check whether you have filled require details correctly"})
else: #if user not login
return render_template('showSignIn.html')
def post(self, username=""):
user = self.getCookieCacheUser()
class_name = self.request.get("class-name")
class_instructor = self.request.get("class-instructor")
class_year = self.request.get("year")
school_id = self.request.get("school_id")
school = School.get_by_id(int(school_id))
if class_name and class_instructor and class_year and school:
new_class = Class(name=class_name,
school=school,
instructor=class_instructor,
year=int(class_year),
user_creator=user,
requests=[])
new_class.other_users.append(str(user.key().id()))
new_class.put()
memcache.set(str(user.key().id()) + class_name, new_class)
memcache.delete(str(user.key().id()))
self.redirect("/%s/%s" % (user.username, new_class.name))
else:
schools = School.all()
self.render("create-class.html",
schools=schools,
class_name=class_name,
class_instructor=class_instructor,
year=class_year,
class_active="active")
def populate_classes():
klass = Class(refno='MTID101',
th_class_name=u'การเรียนรู้เพื่อการเปลี่ยงแปลงสำหรับ MT',
en_class_name='Transformative learning for MT',
academic_year='2560')
db.session.add(klass)
db.session.commit()
def groups(self, *args, **kwargs):
self.stdout.write("Populating classes table")
programs = [
"B.Ed. (Arts)",
"B.Ed. (Social Science)",
"B.Ed. (Social Studies)",
"B.Ed. (Accounting)",
"B.Ed. (Management)",
"B.Ed. (Science),",
"B.Ed. (Mathematics)",
"B.Ed. (Computer Science)",
"B.Ed. (Health Science)",
"B.Ed. (Health, Physical Education & Recreation)",
"B.Ed. (Home Economics)",
"B.Sc. (Computer Science)",
"B.Sc. (Engineering Physics)",
"B.Sc. (Industrial Chemistry)",
"B.Sc. (Information Technology)",
"B.Sc. (Laboratory Technology)",
"B.Sc. (Mathematics)",
]
levels = [1, 2, 3, 4]
for p in programs:
now = datetime.now()
start = date(now.year - random.choice(levels), 8, 21)
end = date(start.year + 4, 8, 21)
Class(
program=p,
size=random.randint(50, 150),
admission_year=start,
completion_year=end,
).save()
def add_class_to_db():
class_list = ['Пятый', 'Шестой', 'Седьмой', 'Восьмой', 'Девятый']
for i in class_list:
to_db = Class(i)
db.session.add(to_db)
db.session.commit()
def create_class(request):
#import pdb; pdb.set_trace()
result_obj = json.loads(request.body)
user_profile = User_Profile.objects.filter(user=request.user)
new_class = Class()
new_class.name = result_obj['name']
new_class.instructor = user_profile[0]
new_class.save()
add_students_in_class(result_obj, new_class.id)
return_obj = {"class_id": new_class.id}
return JsonResponse(return_obj)
def newClass():
form = ClassForm()
if form.validate_on_submit():
name = form.name.data
describe = form.describe.data
post = Class(name=name, describe=describe, user_id=current_user.id)
db.session.add(post)
db.session.commit()
flash('Post success')
return redirect(url_for('index'))
return render_template('newClass.html', form=form)
def migrate_classes():
df = pd.read_csv(os.path.join(path, "data/courses.csv"))
for index, row in tqdm(df.iterrows(), total=len(df.index)):
new_course = {n: row[conversion_dict[n]] for n in conversion_dict}
course = Class.query.filter_by(term=row["Associated Term"],
crn=row["CRN"]).first()
if course and not all(
[course.__dict__[n] == new_course[n] for n in new_course]):
continue
if course:
course.data = new_course
else:
course = Class(**new_course)
db.session.add(course)
db.session.commit()
def get_courses(year, semester):
print("Downloading course list")
s.get("http://yjs.ustc.edu.cn/course/query.asp?mode=dept")
r = s.post(
"http://yjs.ustc.edu.cn/course/m_querybyname.asp",
data="year1=" + year + "&term1=" + semester +
"&querykc=_&submit=%B2%E9+%D1%AF",
headers={"Content-Type": "application/x-www-form-urlencoded"},
)
soup = BeautifulSoup(r.content, "html5lib")
courses = []
for row in soup.find_all("table")[3].find_all("tr")[1:]:
cols = row.find_all("td")
cno = cols[0].text
name = cols[1].text
teacher = cols[2].text
week = cols[3].text
selected = int(cols[5].text)
list_params = ([cols[5].a["href"].split("'")[i]
for i in (1, 3, 5)] if selected else None)
limit = int(cols[6].text)
classes = []
for c in cols[4].text.split(";"):
parts = c.rsplit(": ", 1)
if len(parts) == 1:
location, time = "", parts[0]
else:
location, time = parts
classes.append(Class(location, time))
courses.append(
Course(cno, name, teacher, week, classes, selected, limit, None,
list_params))
for i, course in enumerate(courses):
print("[%s/%s] %s %s" % (i + 1, len(courses), course.cno, course.name))
if course.selected:
course.students = get_students(*course.list_params)
else:
course.students = []
return courses
def editClass():
if request.method == "POST":
class_name = request.form["class_name"]
dept = request.form["dept"]
number = request.form["number"]
desc = request.form["desc"]
new_class = Class(class_name, dept, number, desc)
db_session.add(new_class)
db_session.commit()
data = {
"id": new_class.id,
"class_name": class_name,
"dept": dept,
"number": number,
"desc": desc
}
pusher_client.trigger('table', 'new-class', {'data': data})
return redirect("/editClass", code=302)
else:
classes = Class.query.all()
return render_template('edit-class.html', classes=classes)
def save(self, commit=True):
newclass = Class(classid=self.cleaned_data['classid'],
classname=self.cleaned_data['classname'])
if commit:
newclass.save()
return newclass
def load_data(file_path, teachers_empty_space, groups_empty_space,
subjects_order):
"""
Loads and processes input data, initialises helper structures.
:param file_path: path to file with input data
:param teachers_empty_space: dictionary where key = name of the teacher, values = list of rows where it is in
:param groups_empty_space: dictionary where key = group index, values = list of rows where it is in
:param subjects_order: dictionary where key = (name of the subject, index of the group), value = [int, int, int]
where ints represent start times (row in matrix) for types of classes P, V and L respectively. If start time is -1
it means that that subject does not have that type of class.
:return: Data(groups, teachers, classes, classrooms)
"""
with open(file_path) as file:
data = json.load(file)
# classes: dictionary where key = index of a class, value = class
classes = {}
# classrooms: dictionary where key = index, value = classroom name
classrooms = {}
# teachers: dictionary where key = teachers' name, value = index
teachers = {}
# groups: dictionary where key = name of the group, value = index
groups = {}
class_list = []
for cl in data['Classes']:
new_group = cl['Groups']
new_teacher = cl['Teacher']
# initialise for empty space of teachers
if new_teacher not in teachers_empty_space:
teachers_empty_space[new_teacher] = []
new = Class(new_group, new_teacher, cl['Subject'], cl['Tip'],
cl['Duration'], cl['Classroom'])
# add groups
for group in new_group:
if group not in groups:
groups[group] = len(groups)
# initialise for empty space of groups
groups_empty_space[groups[group]] = []
# add teacher
if new_teacher not in teachers:
teachers[new_teacher] = len(teachers)
class_list.append(new)
# shuffle mostly because of teachers
random.shuffle(class_list)
# add classrooms
for cl in class_list:
classes[len(classes)] = cl
# every class is assigned a list of classrooms he can be in as indexes (later columns of matrix)
for type in data['Classrooms']:
for name in data['Classrooms'][type]:
new = Classroom(name, type)
classrooms[len(classrooms)] = new
# every class has a list of groups marked by its index, same for classrooms
for i in classes:
cl = classes[i]
classroom = cl.classrooms
index_classrooms = []
# add classrooms
for index, c in classrooms.items():
if c.type == classroom:
index_classrooms.append(index)
cl.classrooms = index_classrooms
class_groups = cl.groups
index_groups = []
for name, index in groups.items():
if name in class_groups:
# initialise order of subjects
if (cl.subject, index) not in subjects_order:
subjects_order[(cl.subject, index)] = [-1, -1, -1]
index_groups.append(index)
cl.groups = index_groups
return Data(groups, teachers, classes, classrooms)
from flask import Flask
from models import db, School, Class, Student, Teacher
from routes import classesApi, schoolsApi, teachersApi, studentsApi, index
app = Flask(__name__)
app.register_blueprint(classesApi)
app.register_blueprint(schoolsApi)
app.register_blueprint(teachersApi)
app.register_blueprint(studentsApi)
app.register_blueprint(index)
db.init_app(app)
with app.app_context():
db.create_all()
school = School(name='middle50', address='address')
db.session.add(school)
db.session.commit()
group = Class(name='1A', school_id=school.id)
db.session.add(group)
db.session.commit()
db.session.add(Student(name='Vasya', class_id=group.id))
db.session.add(Teacher(name='Irina', class_id=group.id, subject='Math'))
db.session.commit()
if __name__ == "__main__":
app.run()
def parse_taxonomy(Document):
f = csv.reader(Document, delimiter='\t')
f.next()
for line in f:
subbed = re.sub(r'(\(.*?\)|k__|p__|c__|o__|f__|g__|s__)', '', line[2])
taxon = subbed.split(';')
if not Kingdom.objects.filter(kingdomName=taxon[0]).exists():
kid = uuid4().hex
record = Kingdom(kingdomid=kid, kingdomName=taxon[0])
record.save()
k = Kingdom.objects.get(kingdomName=taxon[0]).kingdomid
if not Phyla.objects.filter(kingdomid_id=k,
phylaName=taxon[1]).exists():
pid = uuid4().hex
record = Phyla(kingdomid_id=k, phylaid=pid, phylaName=taxon[1])
record.save()
p = Phyla.objects.get(kingdomid_id=k, phylaName=taxon[1]).phylaid
if not Class.objects.filter(
kingdomid_id=k, phylaid_id=p, className=taxon[2]).exists():
cid = uuid4().hex
record = Class(kingdomid_id=k,
phylaid_id=p,
classid=cid,
className=taxon[2])
record.save()
c = Class.objects.get(kingdomid_id=k, phylaid_id=p,
className=taxon[2]).classid
if not Order.objects.filter(
kingdomid_id=k, phylaid_id=p, classid_id=c,
orderName=taxon[3]).exists():
oid = uuid4().hex
record = Order(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid=oid,
orderName=taxon[3])
record.save()
o = Order.objects.get(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderName=taxon[3]).orderid
if not Family.objects.filter(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyName=taxon[4]).exists():
fid = uuid4().hex
record = Family(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyid=fid,
familyName=taxon[4])
record.save()
f = Family.objects.get(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyName=taxon[4]).familyid
if not Genus.objects.filter(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyid_id=f,
genusName=taxon[5]).exists():
gid = uuid4().hex
record = Genus(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyid_id=f,
genusid=gid,
genusName=taxon[5])
record.save()
g = Genus.objects.get(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyid_id=f,
genusName=taxon[5]).genusid
if not Species.objects.filter(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyid_id=f,
genusid_id=g,
speciesName=taxon[6]).exists():
sid = uuid4().hex
record = Species(kingdomid_id=k,
phylaid_id=p,
classid_id=c,
orderid_id=o,
familyid_id=f,
genusid_id=g,
speciesid=sid,
speciesName=taxon[6])
record.save()
from models import Class, Data
C1 = [(200, 160, 120), (210, 170, 130), (215, 172, 133), (210, 165, 134),
(198, 177, 138)]
C2 = [(90, 130, 60), (92, 138, 54), (87, 128, 66), (91, 134, 60),
(85, 123, 55)]
C3 = [(30, 44, 178), (20, 40, 180), (24, 42, 184), (28, 50, 176),
(22, 46, 181)]
color_classes = [C1, C2, C3]
classes = []
i = 1
for c in color_classes:
items = []
helper = Class(name="c" + str(i))
for item in c:
items.append(
Data(name="",
characteristics={
"r": item[0],
'b': item[1],
'g': item[2]
}))
helper.load_items(items)
i += 1
classes.append(helper)
def get(self):
# CLEAR All
query = Department.query()
entries = query.fetch()
entry_keys = [entry.key for entry in entries]
ndb.delete_multi(entry_keys)
query = House.query()
entries = query.fetch()
entry_keys = [entry.key for entry in entries]
ndb.delete_multi(entry_keys)
query = Class.query()
entries = query.fetch()
entry_keys = [entry.key for entry in entries]
ndb.delete_multi(entry_keys)
query = Student.query()
entries = query.fetch()
entry_keys = [entry.key for entry in entries]
ndb.delete_multi(entry_keys)
user = users.get_current_user()
if user and users.is_current_user_admin():
# Create houses
houses = ['Gryffindor', 'Hufflepuff', 'Ravenclaw', 'Slytherin']
for house in houses:
House(house_name=house).put()
# Create departments
deps = [
{
'code': 'CS',
'name': 'Computer Science'
},
{
'code': 'BA',
'name': 'Business Administration'
},
{
'code': 'PHY',
'name': 'Physics'
},
{
'code': 'MAT',
'name': 'Mathematics'
},
{
'code': 'DRA',
'name': 'Drama'
},
{
'code': 'ECE',
'name': 'Electrical Engineering'
},
]
for dep in deps:
Department(id=dep['code'], dept_name=dep['name']).put()
# Create 40 classes for department, update depts
classes_count = 40
for dept in deps:
department_key = ndb.Key('Department', dept['code'])
department_obj = department_key.get()
for i in range(classes_count):
class_full_name = "%s - Class %d" % (dept['name'], i)
department = department_key
class_key = Class(id='%s-%d' % (dept['code'], i),
class_full_name=class_full_name).put()
department_obj.classes.append(class_key)
department_obj.put()
# Create students
students_count = 1000
random.seed()
all_classes = Class.query().fetch()
all_houses = House.query().fetch()
for i in range(students_count):
house = random.choice(all_houses)
house_key = house.key
student_name = 'Student %d' % i
student_year = random.randint(1, 4)
current_classes = random.sample(all_classes, 5)
current_classes_keys = [el.key for el in current_classes]
all_classes_keys = [el.key for el in all_classes]
leftovers = set(all_classes_keys) - set(current_classes_keys)
completed_classes_keys = random.sample(leftovers,
6 * (student_year - 1))
student_key = Student(student_name=student_name,
student_year=student_year,
current_classes=current_classes_keys,
completed_classes=completed_classes_keys,
house=house_key).put()
house.students.append(student_key)
for el in current_classes:
el.students_enrolled.append(student_key)
# save new status of houses and current classes
for house in all_houses:
house.put()
for current_class in all_classes:
current_class.put()
elif user and not users.is_current_user_admin():
self.redirect(users.create_logout_url('/create_entries'))
else:
self.redirect(users.create_login_url('/create_entries'))
def test_normal_class(self):
"""test creation of a sample class"""
#create users of class
try:
teacher = Users(username='******', first_name='creswell', last_name='creswell', role=self.admin_role)
teacher.set_password('password')
db.session.add(teacher)
student1 = Users(username='******', first_name='notcreswell', last_name='notcreswell', role=self.user_role)
student1.set_password('password')
db.session.add(student1)
student2 = Users(username='******', first_name='notcreswell2', last_name='notcreswell2', role=self.user_role)
student2.set_password('password')
db.session.add(student2)
except:
self.fail("Failed to create users.")
traceback.print_exc()
#create class
try:
class_ = Class(teacher_id=teacher, name="class", join_code="join")
db.session.add(class_)
except:
self.fail("Failed to create class.")
traceback.print_exc()
#create gradefactor
try:
grade_factor = GradeFactor(class_id=class_.id, category1_name="tests", category1_weight=0.5, category2_name="quizzes", category2_weight=0.5)
db.session.add(grade_factor)
except:
self.fail("Failed to create grade factor.")
traceback.print_exc()
#create gradescale
try:
grade_scale = GradeScale(class_id=class_.id, a_b = 0.9, b_c = 0.8, c_d = 0.7, d_f = 0.6)
db.session.add(grade_scale)
except:
self.fail("Failed to create grade factor.")
traceback.print_exc()
#add students to class
try:
class_student_link1 = ClassStudentLink(student_id=student1.id, class_id=class_.id)
db.session.add(class_student_link1)
class_student_link2 = ClassStudentLink(student_id=student2.id, class_id=class_.id)
db.session.add(class_student_link2)
except:
self.fail("Failed to create class student links.")
traceback.print_exc()
#add assignments
try:
test1 = Assignment(assignment_name="test1", assignment_type=1, assignment_date=datetime.date(2019,1,1), class_id=class_, total_points=100)
db.session.add(test1)
quiz1 = Assignment(assignment_name="quiz1", assignment_type=2, assignment_date=datetime.date(2019,1,1), class_id=class_, total_points=50)
db.session.add(quiz1)
except:
self.fail("Failed to create assignments.")
traceback.print_exc()
#add assignment_results
try:
test1_student1 = AssignmentResult(student_id=student1, assignment_id=test1, points_earned=90)
db.session.add(test1_student1)
quiz1_student_1 = AssignmentResult(student_id=student1, assignment_id=quiz1, points_earned=45)
db.session.add(quiz1_student_1)
test1_student2 = AssignmentResult(student_id=student2, assignment_id=test1, points_earned=80)
db.session.add(test1_student2)
quiz1_student_2 = AssignmentResult(student_id=student2, assignment_id=quiz1, points_earned=40)
db.session.add(quiz1_student_2)
except:
self.fail("Failed to create assignment results.")
traceback.print_exc()
def get_classes_file(clases_file):
if not os.path.isfile(clases_file):
fp = open(clases_file, "w")
fp.writelines("\n".join(["M", "N"]))
print " * %s created" % classes_txt
print " go and modify meet classes"
sys.exit(1)
else:
return open(classes_txt)
if __name__ == "__main__":
# read confg
conf = get_config()
# get engine
engine = create_engine(conf["DATABASE_URI"], echo=True)
from sqlalchemy.orm import sessionmaker
db_session = sessionmaker(bind=engine)()
classes_txt = "classes.txt"
classes = get_classes_file(classes_txt)
print " * Creating classses form: %s" % classes_txt
for line in classes:
class_name = line.strip()
db_session.add(Class(name=class_name))
db_session.commit()
college.name = college_name
db.session.add(college)
college_code += 1
major_code = 9
print(college_name)
for major_name in students_data[college_name].keys():
major = Major()
major.name = major_name
college.majors.append(major)
major_code += 1
print(major_name)
for grade in students_data[college_name][major_name].keys():
print(grade)
for class_code in range(10, 15):
class_name = grade + "级" + major_name + str(class_code) + "班"
class_ = Class()
class_.grade = int(grade)
class_.name = class_name
major.classes.append(class_)
print(class_name)
for student_code in range(10, 30):
last_name = random.choice(last_names)
sex = random.choice(["male", "female"])
first_name = random.choice(first_names[sex])
name = last_name + first_name
student = Student()
student.name = name
student.id = int(grade[-2:] + str(college_code) +
str(major_code) + str(class_code) +
str(student_code))
student.password_hash = "pbkdf2:sha256:150000$LssWNeqi$de05643547efe747ad0a14b74ac2e0e036e2d21fcae3be98bd43c94392f2226d"
