def setUp(self):
self.student = Student('test1', 123)
self.course1 = Course(1, 'test_course1')
self.course2 = Course(2, 'test_course2')
self.course3 = Course(3, 'test_course3')
self.course4 = Course(4, 'test_course4')
self.enrollment1 = Enrollment(self.student, self.course1)
self.enrollment2 = Enrollment(self.student, self.course2)
self.enrollment3 = Enrollment(self.student, self.course3)
def transform_to_anti_req_obj(anti_req_string):
anti_req_obj = AntiRequisites()
# Split the string on various delimiters
# Replace is to replace any 'and' joiners at the end of lists
split_anti_req_string = re.split(r', and |, the former |, ', anti_req_string.replace('B and ', ', '))
anti_req_course_list = []
for course_name in split_anti_req_string:
# If the course_name has more than one course joined by 'or'
if 'B or ' in course_name:
list_of_or_courses = []
for course in course_name.split(' or '):
course_dept_and_code = course.rsplit(' ', 1)
temp_course = Course(course_dept_and_code[0], re.sub("[^0-9]", "", course_dept_and_code[1]),
re.sub("[^A-Z/]", "", course_dept_and_code[1]))
list_of_or_courses.append(temp_course)
setattr(anti_req_obj, 'one_of', list_of_or_courses)
# If course_name contains an anti-req taken during a specific session (Fall/Winter, Summer, etc.)
elif 'if taken during' in course_name:
course_name_list = course_name.split(' if taken during ')
course_dept_and_code = course_name_list[0].rsplit(' ', 1)
temp_course = Course(course_dept_and_code[0], re.sub("[^0-9]", "", course_dept_and_code[1]),
re.sub("[^A-Z/]", "", course_dept_and_code[1]))
school_session = course_name_list[1].replace('the ', '')
# If the course_name contains the phrase 'academic year', that means full year
if 'academic year' in course_name_list[1]:
year_anti_req_map = {
'term': 'Year',
'years': school_session.split(' ', 1)[0].split('-')
}
setattr(temp_course, 'if_taken_in', year_anti_req_map)
# Else, all other instances can be processed into session and years
else:
year_anti_req_map = {
'term': school_session.split(' ', 1)[0],
'years': school_session.split(' ', 1)[1].replace(' or ', ',').split(' ')[0].split(',')
}
setattr(temp_course, 'if_taken_in', year_anti_req_map)
# Append the course object to the anti-req course list
anti_req_course_list.append(temp_course)
# No special handling, split into course dept and course code and create Course obj
else:
course_dept_and_code = course_name.rsplit(' ', 1)
temp_course = Course(course_dept_and_code[0], re.sub("[^0-9]", "", course_dept_and_code[1]),
re.sub("[^A-Z/]", "", course_dept_and_code[1]))
anti_req_course_list.append(temp_course)
anti_req_obj.course_list = anti_req_course_list
return anti_req_obj
def create_course(self, name, description, language=None, problems=None):
if problems:
course = Course(name=name,
description=description,
language=language,
_problems=problems)
else:
course = Course(name=name,
description=description,
language=language)
self.owned_courses.append(course)
db.session.add(course)
db.session.commit()
course.add_member(self)
return course
def getCourseByCourseId(self, course_id):
"""
获取课程模型
:param course_id: 课程id
:return: 存在返回course对象，否则返回None
"""
sql = "SELECT * FROM course WHERE id=%s"
self.cursor.execute(sql, course_id)
res = self.cursor.fetchall()
course = None
err = ErrorCode.NoError
if len(res) == 0:
err = ErrorCode.ResourceNotFoundError
else:
dict = res[0] # 返回是一个列表，取第一个（也只有一个）
course = Course(id=str(dict["id"]),
name=dict["name"],
key=dict["key"],
creator_id=str(dict["creator_id"]),
create_timestamp=dict["create_timestamp"],
status=dict["status"],
notice=dict["notice"],
introduction=dict["introduction"],
joinable=dict["joinable"])
return course, err
def _get_open_courses(data):
req = requests.post(url, data=data)
soup = BeautifulSoup(req.content, 'html5lib')
rows = soup.select('table.dataentrytable tbody tr')
open_courses = list()
# The first row is the header row with the column labels
# If there's only one row, the rest of the table is empty, so there are no results
if len(rows) > 1:
rows = rows[1:]
for row in rows:
cells = row.select('td')
cells_text = list(map(lambda x: x.get_text(), cells))
crn = cells_text[0].strip()
label = cells_text[1].strip()
title = cells_text[2].strip()
professor = cells_text[6].strip()
open_courses.append(Course(crn, label, title, professor))
return open_courses
def run(self, **kwargs):
from models.user import User
from models.course import Course
from models.role import Role
with open('settings/secrets.json', 'r') as secret_file:
secrets = json.load(secret_file).get("ADMIN", {})
print("Adding Admin")
admin = User(first_name=secrets.get("first_name", "Admin"),
last_name=secrets.get("last_name", "User"),
password=hash_password(secrets.get(
"password", "password")),
confirmed_at=datetime.datetime.now(),
active=True,
email=secrets.get("email", "*****@*****.**"))
db.session.add(admin)
db.session.flush()
db.session.add(Role(name='instructor', user_id=admin.id))
db.session.add(Role(name='admin', user_id=admin.id))
print("Adding default course")
default_course = Course(name="Default Course",
owner_id=admin.id,
service="native")
db.session.add(default_course)
db.session.flush()
db.session.add(
Role(name='instructor',
course_id=default_course.id,
user_id=admin.id))
db.session.commit()
print("Complete")
def setUp(self):
student = Student('test', 1)
course = Course(1, 'test_course')
datetime_format = '%Y-%m-%dT%H:%M:%SZ'
assignment = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course,
datetime_format)
self.grade = Grade(student, course, assignment, 0.85)
def get_courses(self, html):
tbody = re.findall(r"<tbody[^>]*>[\s\S]*?</tbody>\s*", html)[0]
courses = re.findall(r"<tr[^>]*>[\s\S]*?</tr>\s*", tbody)
for i, course_data in enumerate(courses):
course = Course(course_data)
courses[i] = course
return courses
def dci_from_data(dataset, db, conn):
for model in [Department(), Course(), Instructor()]:
sanitized_data = list(map(model.sanitize_from_raw, dataset))
sanitized_data = list({v['id']: v for v in sanitized_data}.values())
modeltable = model.__class__.__name__
result = r.db(db).table(modeltable).insert(sanitized_data).run(conn)
inserted = result['inserted']
errors = result['errors']
logging.info("{0} Inserted \t {1} \t Skipped {2}".format(
modeltable.ljust(12), inserted, errors))
def create_course():
if request.method == 'POST':
name = request.form['name']
url_prefix = request.form['url_prefix']
tag_name = request.form['tag_name']
query = json.loads(request.form['query'])
Course(name, url_prefix, tag_name, query).save_to_mongo()
# What happens if it's a GET request
return render_template("courses/new_course.html")
def select_course(self):
while True:
cou = Course().show_info()
no = input("请选择课程：")
try:
self.course = cou[int(no)][1]
except Exception as e:
print(e, "选择错误请重新选择！")
else:
row_index = self.find_username(self.username)[0]
self.updata(row_index, "course", self.course)
break
def create_course(name, summary, course_url, subject):
session = db_session.create_session()
c = Course()
c.name = name
c.summary = summary
c.course_url = course_url
c.subject_id = subject.id
session.add(c)
session.commit()
return c
def get_course(id):
sql = "Select * from courses where id = %s"
cursor = connection.cursor()
cursor.execute(sql, [id])
record = cursor.fetchone()
course = Course(id=record[0],
name=record[1],
start_date=record[3],
end_date=record[4],
cost=record[6])
course.type = CourseTypeDao.get_course_type(record[2])
course.grading_format = GradingFormatDao.get_format(record[5])
return course
def run(self, site, messages=None):
site.clear()
show_messages(messages)
serial = get_input('Course Serial: ')
title = get_input('Title: ')
course = Course(serial=serial, title=title, owner=site.active_user)
if course.is_valid(site.course_list):
site.add_course(course)
else:
return course.errors
return None
def pay(self):
# 1.查询课程金额
if self.is_pay():
print("该课程您已购买,请勿重复操作！")
return True
if self.course is not None or self.course != "None":
try:
cou = Course().find("name", self.course)
money = float(cou[0][1][2])
self.__pay(money)
except Exception as e:
print(e)
else:
print("请先选择课程！")
return False
def insertCourse():
if request.method == 'POST':
course_id = request.form['course_id']
name = request.form['name']
department = request.form['department']
professor = request.form['professor']
classroom = request.form['classroom']
course = Course(course_id, name, department, professor, classroom,)
if insertCourse(course):
return redirect(url_for('home'))
else:
error = 'ERROR'
return render_template('insert-course.html', error=error)
else:
return render_template('insert-course.html')
def load_test(self):
admin = User(
username='******',
password='******',
role='Manager',
email='admin@localhost',
phone_number='09123456789',
serial='96000000',
verified=True
)
self.user_list.append(admin)
teacher = User(
username='******',
password='******',
name='Moallem',
role='Teacher',
email='2@localhost',
phone_number='09123456789',
serial=None,
verified=True
)
self.user_list.append(teacher)
student = User(
username='******',
password='******',
role='Student',
email='1@localhost',
phone_number='09123456789',
serial='96000001',
field='Math',
verified=True,
name='Mammad Sarab'
)
self.user_list.append(student)
course = Course(
serial='40122',
owner=teacher,
title='Stats',
verified=True
)
self.course_list.append(course)
teacher.course_list.append(course)
def setUp(self):
student = Student('test', 1)
course = Course(1, 'test_course')
datetime_format = '%Y-%m-%dT%H:%M:%SZ'
assignment1 = Assignment(1, 'hw1', '2018-01-02T23:59:00Z', course,
datetime_format)
assignment2 = Assignment(2, 'hw2', '2018-01-02T23:59:00Z', course,
datetime_format)
assignment3 = Assignment(3, 'hw3', '2018-01-02T23:59:00Z', course,
datetime_format)
assignment4 = Assignment(4, 'hw4', '2018-01-02T23:59:00Z', course,
datetime_format)
self.grade1 = Grade(student, course, assignment1, 0.85)
self.grade2 = Grade(student, course, assignment2, 0.75)
self.grade3 = Grade(student, course, assignment3, 0.65)
self.grade4 = Grade(student, course, assignment4, 0.55)
self.enrollment = Enrollment(student, course, [self.grade1], 0.75)
def digest_file(filename, db, conn):
data = dataSet('data/csv/' + filename)
fcq_data = list(map(Fcq().sanitize_from_raw, data.raw_data))
for model in [Department(), Course(), Instructor()]:
sanitized_data = list(map(model.sanitize_from_raw, fcq_data))
sanitized_data = list({v['id']: v for v in sanitized_data}.values())
modeltable = model.__class__.__name__
result = r.db(db).table(modeltable).insert(sanitized_data).run(conn)
inserted = result['inserted']
errors = result['errors']
logging.info("{0} Inserted \t {1} \t Skipped {2}".format(modeltable.ljust(12), inserted, errors))
result = r.db(db).table('Fcq').insert(fcq_data).run(conn)
inserted = result['inserted']
errors = result['errors']
logging.info("{0} \t Inserted {1}".format(filename.ljust(12), inserted))
if errors:
first_error = result['first_error']
logging.warn("{0} Errors inserting fcqs. First Error:\n{1}".format(errors, first_error))
def create():
params = request.form
new_course = Course(title=params.get("course_title"),
teacher_id=current_user.id)
if new_course.save():
# print("new_course.id",new_course.id)
new_thread = Thread(course=new_course.id)
new_thread.save()
# print("new thread", new_thread.id)
flash("Successfully Created a Course!", "success")
return redirect(
url_for("users.show",
username=current_user.username,
user_id=current_user.id)) # then redirect to profile page
else:
flash(new_course.errors, "danger")
return redirect(url_for("users.show"))
def test_get_course(client):
Course.objects().delete()
response = client.get("/api/class/10000")
assert response.status_code == 404
course = {
"course_id": 10000,
"title": "Geometric and Topological Data Analysis",
"description":
"The goal of this course is to cover the rudiments of geometric and topological methods that have proven useful in the analysis of geometric data, using classical as well as deep learning approaches.",
"instructor": 100,
"prerequisites": [9001, 9002],
"enrolled_students": list(range(500, 530)),
"recurring": False,
"start_date": datetime(2000, 1, 1),
"end_date": datetime(2000, 4, 1),
"year": 2000,
"time_added": datetime.now()
}
Course(**course).save()
response = client.get("/api/class/10000")
assert response.status_code == 200
data = response.get_json()
assert data['course_id'] == course['course_id']
assert data['title'] == course['title']
assert data['description'] == course['description']
assert data['instructor'] == course['instructor']
assert data['prerequisites'] == course['prerequisites']
assert data['enrolled_students'] == course['enrolled_students']
assert data['recurring'] == course['recurring']
assert data['year'] == course['year']
response = client.get("/api/class/10001")
assert response.status_code == 404
Course.objects().delete()
def transform_to_pre_req_obj(pre_req_string):
pre_req_obj = PreRequisites()
pre_req_course_list = []
if "Either" in pre_req_string:
pass
elif "or" in pre_req_string:
pass
elif "course" in pre_req_string:
pass
else:
# Since recommended courses are not required, we will ignore them and create the pre-req list
pre_req_string_remove_recs = pre_req_string.split(';')[0]
pre_req_list = re.split(r' and |, ', pre_req_string_remove_recs)
for course_name in pre_req_list:
course_dept_and_code = course_name.rsplit(' ', 1)
temp_course = Course(course_dept_and_code[0], re.sub("[^0-9]", "", course_dept_and_code[1]),
re.sub("[^A-Z/]", "", course_dept_and_code[1]))
pre_req_course_list.append(temp_course)
pre_req_obj.course_list = pre_req_course_list
return pre_req_obj
# Create the instructor object from db info and grab all their courses from db
instructor = Instructor(first_name=i['first_name'],
last_name=i['last_name'],
email=i['email'],
lms_id=i['lms_id'],
color_blind_mode=i['color_blind_mode'])
INSTRUCTOR_COURSES = f'''SELECT DISTINCT lms_id, short_name, alias
FROM courses
WHERE instructor_id = %s AND is_monitored=TRUE'''
params = (i['id'], )
instructor_courses_dict = db.run_query(INSTRUCTOR_COURSES, cursor,
params)
instructor.add_courses([
Course(lms_id=c['lms_id'],
short_name=c['short_name'],
alias=c['alias']) for c in instructor_courses_dict
])
for course in instructor.courses:
logger.info(
f'Getting grades/assignments for {course.short_name}...')
# Get the students, enrollments, assigments, and grades for this course
students_dict = lms_obj.get_students_in_course(course.lms_id)
if students_dict is None:
continue
students = [
Student(name=student['name'], lms_id=student['lms_id'])
for student in students_dict
]
course.add_students(students)
from modules.fcq_card_module import FcqCardModule
from models.fcq import Fcq
from models.grade import Grade
from models.course import Course
from models.instructor import Instructor
from models.department import Department
from handlers.not_found_handler import NotFoundHandler
import logging
settings = {
'cookie_secret': 'PqITv9b7QUyoAUUcgfRtReoZIXjQrEKKk9fpQpGu6MU=',
'template_path': 'templates/',
'static_path': 'static/',
'grade': Grade(),
'fcq': Fcq(),
'course': Course(),
'instructor': Instructor(),
'department': Department(),
'default_handler_class': NotFoundHandler,
'ui_modules': {
'chart_overtime': LineChartModule,
'fcq_card': FcqCardModule
}
}
def initialize_settings():
settings['debug'] = options.debug
settings['autoreload'] = options.debug
settings['site_port'] = options.port
database_name = options.database_name
def setUp(self):
# Course with alias
self.course1 = Course(1, 'TEST123')
# Course without alias
self.course2 = Course(2, 'TEST123', 'My test course')
def create_course(self):
return CourseDao.create_course(
Course("Test name", datetime.now(), datetime.now(), 10), False)
def setUp(self):
self.instructor = Instructor('john', 'smith', '*****@*****.**',
123)
self.course1 = Course(1, 'test_course1')
self.course2 = Course(2, 'test_course2')
self.course3 = Course(3, 'test_course3')
def fetch_rows(table, criteria, connection):
objs = []
try:
cur = connection.cursor()
#--- SPLIT NULLS FROM NOT NULLS + COMMON WORK---#
null_criteria = {}
deleters = []
for key in criteria:
if (criteria[key] is None):
null_criteria[key] = None
deleters.append(key)
for key in deleters:
criteria.pop(key, None)
null_phrase = ('IS NULL AND '.join(null_criteria.keys())) + " IS NULL "
not_null_phrase = '= %s AND '.join(criteria.keys()) + "= %s"
if (null_criteria and not criteria):
crit_phrase = " WHERE " + null_phrase
elif (criteria and not null_criteria):
crit_phrase = " WHERE " + not_null_phrase
elif (criteria and null_criteria):
crit_phrase = " WHERE " + null_phrase + "AND " + not_null_phrase
else:
crit_phrase = ""
#--------------------------------#
if (table == "in"):
select_phrase = "SELECT * FROM instructors"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
instructor = Instructor(row[0], row[1], row[2], row[3], row[4],
row[5], row[6])
objs.append(instructor)
row = cur.fetchone()
if (table == "co"):
select_phrase = "SELECT * FROM courses"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
course = Course(row[0], row[1], row[2], row[3], row[4], row[5],
row[6], row[7], row[8])
objs.append(course)
row = cur.fetchone()
if (table == "st"):
select_phrase = "SELECT * FROM students"
sql = select_phrase + crit_phrase
#print(cur.mogrify(sql, (list(criteria.values()))))
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
student = Student(row[0], row[1], row[2], row[3], row[4],
row[5])
objs.append(student)
row = cur.fetchone()
if (table == "cs"):
select_phrase = "SELECT * FROM coursestudents"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
coursestudent = Coursestudent(row[0], row[1])
objs.append(coursestudent)
row = cur.fetchone()
if (table == "as"):
select_phrase = "SELECT * FROM assignments"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
assignment = Assignment(row[0], row[1], row[2], row[3], row[4],
row[5], row[6], row[7], row[8], row[9])
objs.append(assignment)
row = cur.fetchone()
if (table == "su"):
select_phrase = "SELECT * FROM submissions"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
submission = Submission(row[0], row[1], row[2], row[3], row[4],
row[5], row[6], row[7])
objs.append(submission)
row = cur.fetchone()
if (table == "com"):
select_phrase = "SELECT * FROM comments"
sql = select_phrase + crit_phrase
cur.execute(sql, (list(criteria.values())))
row = cur.fetchone()
while row is not None:
comment = Comment(row[0], row[1], row[2], row[3])
objs.append(comment)
row = cur.fetchone()
connection.commit()
cur.close()
except Exception as error:
print(error)
return objs
