def delete_year():
#try:
data_j = json.loads(request.data)
token = data_j["token"]
year = data_j["year"]
db = get_db()
db.execute('DELETE FROM instructors WHERE (year = ' + '"' + year + '"' +
' AND token = ' + '"' + token + '")')
db.execute('DELETE FROM courses WHERE (year = ' + '"' + year + '"' +
' AND token = ' + '"' + token + '")')
db.execute('DELETE FROM sections WHERE (year = ' + '"' + year + '"' +
' AND token = ' + '"' + token + '")')
db_years = db.execute('SELECT years FROM users WHERE token =' + '"' +
token + '"')
desc = db_years.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_years.fetchall()]
buffer = data[0]["years"].split()
buffer.remove(year)
db.execute('UPDATE users'
' SET years =' + '"' + (" ".join(buffer)) + '"' +
' WHERE token =' + '"' + token + '"')
db.commit()
db.close()
return jsonify({'message': 'Year Deleted'}), 200
#except:
return jsonify({'message': 'Error'}), 500
def get_course():
try:
data_j = json.loads(request.data)
course_id = data_j['course_id']
year = data_j['year']
token = data_j['token']
db = get_db()
if (admin.check_admin(token) == False):
db_course = db.execute(
'SELECT name, course_id, owner, year, freq_spr, freq_sum1, freq_sum2, freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l, owner, token'
' FROM courses'
' WHERE (year = ' + '"' + year + '"' + ' AND course_id = ' +
'"' + course_id + '"'
' AND token = ' + '"' + token + '")')
else:
db_course = db.execute(
'SELECT name, course_id, owner, year, freq_spr, freq_sum1, freq_sum2, freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l, owner, token'
' FROM courses'
' WHERE (year = ' + '"' + year + '"' + ' AND course_id = ' +
'"' + course_id + '")')
desc = db_course.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_course.fetchall()]
if (len(data) == 0):
return jsonify({"message": "bad"})
return json.dumps(data[0])
except:
admin.create_log(request,
"Error caught in get_course() located in courses.py")
return jsonify({
'message':
'error encountered, please contact server administrator'
})
def get_instructors(prev=False):
data_j = json.loads(request.data)
year = data_j['year']
token = data_j['token']
if (prev == True):
year = str(int(data_j["year"]) - 1)
instructors = {}
db = get_db()
if (admin.check_admin(token) == False):
print("Check Admin is False")
db_instructors = db.execute(
'SELECT name, net_id, preps, rank, wl_credits, wl_courses, summer, year, preferred_courses, available_courses, owner, token'
' FROM instructors WHERE (year = ' + '"' + year + '"' +
' AND token = ' + '"' + token + '")')
else:
print("Check Admin is True")
db_instructors = db.execute(
'SELECT name, net_id, preps, rank, wl_credits, wl_courses, summer, year, preferred_courses, available_courses, owner, token'
' FROM instructors WHERE year = ' + '"' + year + '"')
desc = db_instructors.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_instructors.fetchall()]
return json.dumps(data)
def edit_instructor():
data_j = json.loads(request.data)
if request.method == 'POST':
name = data_j['name']
net_id = data_j['net_id']
year = data_j['year']
preps = data_j['preps']
wl_credits = data_j['wl_credits']
wl_courses = data_j['wl_courses']
token = data_j['token']
available_courses = data_j['available_courses'][0]
for course in data_j['available_courses']:
if available_courses != course:
available_courses = available_courses + " " + course
print(available_courses)
db = get_db()
db.execute('DELETE FROM instructors WHERE (net_id = ' + '"' + net_id +
'"' + ' AND year = ' + '"' + year + '"' + ' AND token = ' +
'"' + token + '")')
db.execute(
'INSERT INTO instructors (name, net_id, preps, year, wl_credits, wl_courses, available_courses, token)'
' VALUES (?, ?, ?, ?, ?, ?, ?, ?)',
(name, net_id, preps, year, wl_credits, wl_courses,
available_courses, token))
db.commit()
db.close()
return jsonify({'message': 'instructor edited!'}), 200
return jsonify({'message': "I don't know what happened! Sorry."}), 200
def get_courses(prev=False):
try:
data_j = json.loads(request.data)
year = data_j['year']
token = data_j['token']
if (prev == True):
year = str(int(data_j["year"]) - 1)
db = get_db()
if (admin.check_admin(token) == False):
db_courses = db.execute(
'SELECT name, course_id, owner, year, freq_spr, freq_sum1, freq_sum2, freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l'
' FROM courses WHERE year =' + '"' + year + '"' +
'AND token=' + '"' + token + '"')
else:
db_courses = db.execute(
'SELECT name, course_id, owner, year, freq_spr, freq_sum1, freq_sum2, freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l'
' FROM courses WHERE year =' + '"' + year + '"')
desc = db_courses.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_courses.fetchall()]
return json.dumps(data)
except:
create_log(request,
"Error caught in get_courses() located in courses.py")
return jsonify({
'message':
'error encountered, please contact server administrator'
})
def assign_course():
try:
data_j = json.loads(request.data)
sem = data_j["sem"]
course_id = data_j["course_id"]
instructor_id = data_j["instructor_id"]
section_number = data_j["section_number"]
instructor_name = data_j["instructor_name"]
year = data_j["year"]
course_name = data_j["course_name"]
id = data_j["id"]
token = data_j["token"]
db = get_db()
if instructor_name is None or instructor_name == "choose instructor" or instructor_id == "unassign":
instructor_name = "Unassigned"
instructor_id = "Unassigned"
db.execute('UPDATE sections SET instructor_id = ' + '"' +
instructor_id + '"' + ', instructor_name = ' + '"' +
instructor_name + '"' + ', section_number = ' + '"' +
section_number + '"' + ' WHERE (id = ' + str(id) +
' AND year = "' + year + '")')
if instructor_name != "Unassigned":
admin.create_log(
request, "assigned " + instructor_name + " to " + course_name +
": " + section_number)
db.commit()
return jsonify({"message": "instructors assigned!"}), 200
except:
admin.create_log(
request, "Error caught in assign_course() located in sections.py")
return jsonify({"message": "failure"}), 200
def pull_from_csv():
section = 1
db = get_db()
df = pd.DataFrame.from_csv("instructors.csv")
for row in df.iterrows():
db.execute(
'INSERT INTO instructors (name, net_id, preps, wl_credits, wl_courses, year, preferred_courses, available_courses, owner, token)'
' VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
(row[1]['name'], row[0], row[1]['preps'], row[1]['wl_credits'],
row[1]['wl_courses'], row[1]['year'], row[1]['preferred_courses'],
row[1]['available_courses'], row[1]['owner'], row[1]['token']))
db.commit()
df = pd.DataFrame.from_csv("courses.csv")
for row in df.iterrows():
data_j = {}
data_j["course_id"] = row[0]
data_j["name"] = row[1]['name']
data_j["owner"] = row[1]['owner']
data_j["freq_spr"] = row[1]['freq_spr']
data_j["freq_sum1"] = row[1]['freq_sum1']
data_j["freq_sum2"] = row[1]['freq_sum2']
data_j["freq_fal"] = row[1]['freq_fal']
data_j["freq_spr_l"] = row[1]['freq_spr_l']
data_j["freq_sum1_l"] = row[1]['freq_sum1_l']
data_j["freq_sum2_l"] = row[1]['freq_sum2_l']
data_j["freq_fal_l"] = row[1]['freq_fal_l']
data_j["year"] = row[1]['year']
data_j["owner"] = row[1]['owner']
data_j["token"] = row[1]['token']
create_sections(db, data_j, data_j["token"])
db.execute(
'INSERT INTO courses (course_id, name, owner, freq_spr, freq_sum1, freq_sum2, freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l, year, owner, token)'
' VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
(row[0], row[1]['name'], row[1]['owner'], row[1]['freq_spr'],
row[1]['freq_sum1'], row[1]['freq_sum2'], row[1]['freq_fal'],
row[1]['freq_spr_l'], row[1]['freq_sum1_l'],
row[1]['freq_sum2_l'], row[1]['freq_fal_l'], row[1]['year'],
row[1]['owner'], row[1]['token']))
db.commit()
db.execute(
'INSERT INTO users (username, token, test_password, years, default_year) VALUES ("pqt3", "test", "test", "2019", "2019")'
)
db.execute(
'INSERT INTO users (username, token, test_password, years, default_year) VALUES ("kcm91", "test2", "test2", "2019", "2019")'
)
db.execute(
'INSERT INTO users (username, token, test_password, years, default_year) VALUES ("daj65", "test3", "test3", "2019", "2019")'
)
db.execute(
'INSERT INTO users (username, token, test_password, years, default_year) VALUES ("stan", "test4", "test4", "2019", "2019")'
)
db.execute('INSERT INTO admins (token) VALUES ("test4")')
db.commit()
db.close()
return jsonify({'message': 'bad'}), 200
def get_course_names():
data_j = json.loads(request.data)
year = data_j['year']
db = get_db()
db_courses = db.execute('SELECT name'
' FROM courses WHERE year = "' + str(year) + '"')
desc = db_courses.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_courses.fetchall()]
return json.dumps(data)
def get_course_sections(course_id, year, token):
db = get_db()
db_sections = db.execute(
'SELECT id, course_id, section_number, instructor_id, instructor_name, sem, year, course_name, is_lab'
' FROM sections'
' WHERE course_id = ' + '"' + course_id + '"'
' AND year = "' + year + '"')
desc = db_sections.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_sections.fetchall()]
return data
def section_assignment_warnings(client_warnings, course, course_object,
data_j):
db = get_db()
readable_list = {
"spr": "spring",
"sum1": "summer I",
"sum2": "summer II",
"fal": "fall",
"spr_l": "spring labs",
"sum1_l": "summer I labs",
"sum2_l": "summer II labs",
"fal_l": "fall labs"
}
count_list = {
"spr": 0,
"sum1": 0,
"sum2": 0,
"fal": 0,
"spr_l": 0,
"sum1_l": 0,
"sum2_l": 0,
"fal_l": 0
}
for section in get_course_sections(course['course_id'], data_j['year'],
data_j['token']):
if (section["instructor_id"] != "Unassigned"):
if section["is_lab"] == "True":
string_add = "_l"
else:
string_add = ""
if section["sem"] == "Spr":
count_list["spr" + string_add] += 1
if section["sem"] == "Sum1":
count_list["sum1" + string_add] += 1
if section["sem"] == "Sum2":
count_list["sum2" + string_add] += 1
if section["sem"] == "Fal":
count_list["fal" + string_add] += 1
if (course['name'] == "Ceramics"):
print(count_list)
for key in count_list:
if (course['name'] == "Ceramics"):
print("Ceramics")
print(key)
print(count_list[key])
print("compared to")
print(course["freq_" + key])
if (count_list[key] < int(course["freq_" + key])):
client_warnings.generate(
course_object, course["course_id"] + " " +
str(count_list[key]) + " /" + " " + course["freq_" + key] +
" (" + readable_list[key] + ")" + " assigned.", 2)
def logout():
try:
print("Logging Out")
ip = request.remote_addr
db = get_db()
db.execute('DELETE from login_cache WHERE ip =' + '"' + ip + '"')
db.commit()
db.close()
admin.create_log(request, "Successfully logged out")
return jsonify({"username": "******", "token": " "})
except:
admin.create_log(request,
"Error caught in logout() located in login.py")
def filter_instructors():
data_j = json.loads(request.data)
course_id = data_j['course_id']
year = data_j['year']
token = data_j['token']
instructors_list = turn_instructors_to_objects(year, token)
sections_list = sections.turn_sections_to_objects(year, token)
weights = {}
filtered_ids = []
for i in instructors_list:
courses_taught = []
numCredits = float(i.wl_credits)
for s in sections_list:
if (s.instructor_id == i.net_id):
if (s.section_number[0] == 'L'):
numCredits -= 1.5
else:
numCredits -= 3
courses_taught.append(s.course_id)
weights[i.net_id] = numCredits
try:
if (course_id in i.preferred_courses):
weights[i.net_id] = weights[i.net_id] + 5
except:
pass
if (course_id in courses_taught):
weights[i.net_id] = weights[i.net_id] + 2
if (course_id not in i.available_courses):
weights[i.net_id] = 0
top_weights = sorted(weights, key=weights.get, reverse=True)[:3]
for w in top_weights:
for i in instructors_list:
if (w == i.net_id):
filtered_ids.append(w)
db = get_db()
db_instructors = db.execute(
'SELECT name, net_id, preps, wl_credits, wl_courses, summer, preferred_courses, available_courses'
' FROM instructors WHERE year = ' + '"' + year + '"' +
' AND token = ' + '"' + token + '"')
desc = db_instructors.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_instructors.fetchall()]
filtered_instructors = []
for ID in filtered_ids:
for i in data:
if i['net_id'] == ID:
filtered_instructors.append(i)
return json.dumps(filtered_instructors)
def update_login_cache(ip, username, token, default_year):
try:
db = get_db()
db.execute('DELETE from login_cache WHERE ip =' + '"' + ip + '"')
db.execute(
'INSERT INTO login_cache (ip, username, token, default_year)'
' VALUES (?, ?, ?, ?)', (ip, username, token, default_year))
db.commit()
db.close()
return
except:
admin.create_log(
request,
"Error caught in update_login_cache() located in login.py")
def get_sections_spr():
data_j = json.loads(request.data)
course_id = data_j["course_id"]
year = data_j['year']
db = get_db()
db_sections = db.execute(
'SELECT id, course_id, section_number, instructor_id, instructor_name, sem, year, course_name, token'
' FROM sections'
' WHERE course_id = ' + '"' + course_id + '"'
' AND sem = "Spr" AND year = "' + year + '"')
desc = db_sections.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_sections.fetchall()]
return json.dumps(data)
def get_years():
db = get_db()
data_j = json.loads(request.data)
token = data_j["token"]
print(token)
db_year = db.execute('SELECT years'
' FROM users'
' WHERE token = ' + '"' + token + '"')
desc = db_year.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_year.fetchall()]
if (len(data) == 0):
return jsonify({"message": "no years"})
return json.dumps(data[0])
def turn_courses_to_objects(year):
course_objects = {}
db = get_db()
db_courses = db.execute(
'SELECT name, course_id, owner, year, freq_spr, freq_sum1, freq_sum2, freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l'
' FROM courses WHERE year =' + '"' + year + '"')
desc = db_courses.description
column_names = [col[0] for col in desc]
courses = [dict(zip(column_names, row)) for row in db_courses.fetchall()]
for c in courses:
course_objects[c["course_id"]] = Course(
c['course_id'], c["name"], c["owner"], c["year"], c["freq_spr"],
c["freq_sum1"], c["freq_sum2"], c["freq_fal"], c["freq_spr_l"],
c["freq_sum1_l"], c["freq_sum2_l"], c["freq_fal_l"])
return course_objects.values()
def turn_sections_to_objects(year, token):
section_objects = {}
db = get_db()
db_sections = db.execute(
'SELECT id, course_id, section_number, instructor_id, sem, year, course_name'
' FROM sections WHERE year = "' + year + '" AND token = "' + token +
'"')
desc = db_sections.description
column_names = [col[0] for col in desc]
sections = [dict(zip(column_names, row)) for row in db_sections.fetchall()]
print(len(sections))
for s in sections:
section_objects[s["id"]] = classes.Section(
s['id'], s['section_number'], s["course_id"], s["instructor_id"],
s["sem"], s["year"], s["course_name"])
return section_objects.values()
def check_admin(token):
try:
db = get_db()
db_admins = db.execute('SELECT token FROM admins WHERE token = ' +
'"' + token + '"')
desc = db_admins.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_admins.fetchall()]
if len(data) != 0:
return True
print("This is an admin")
else:
return False
except:
create_log(request,
"Error caught in check_admin() located in admin.py")
def check_login_cache():
try:
db = get_db()
ip = request.remote_addr
db_user = db.execute('SELECT username, token, default_year'
' FROM login_cache WHERE ip=' + '"' + ip + '"')
desc = db_user.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_user.fetchall()]
db.close()
if (len(data) == 0):
return jsonify({"username": "******", "test_password": "******"})
return json.dumps(data[0])
except:
admin.create_log(
request, "Error caught in check_login_cache() located in login.py")
def delete_instructor():
data_j = json.loads(request.data)
net_id = data_j['net_id']
token = data_j['token']
year = data_j['year']
db = get_db()
db.execute(
'UPDATE sections'
' SET instructor_id = "Unassigned", instructor_name = "Unassigned"'
' WHERE (year = ' + '"' + year + '"' + ' AND instructor_id = ' + '"' +
net_id + '"' + ' AND token = ' + '"' + token + '")')
db.execute('DELETE FROM instructors WHERE (net_id = ' + '"' + net_id +
'"' + ' AND year = ' + '"' + year + '"' + ' AND token = ' +
'"' + token + '")')
db.commit()
db.close()
return jsonify({'message': 'instructor deleted!'}), 200
def course_mismatch_warnings(client_warnings, instructor, instructor_object,
data_j):
db = get_db()
if instructor['available_courses'] is None:
instructor['available_courses'] = "Nothing"
for section in get_instructor_sections(instructor['net_id'],
data_j['year'], data_j['token']):
if section['course_id'] not in instructor['available_courses'].split():
if section['sem'] == "Fal":
client_warnings.generate(
instructor_object, instructor['name'] +
" - assigned unavailable course (fall): " +
section['course_name'], 3)
elif section['sem'] == "Spr":
client_warnings.generate(
instructor_object, instructor['name'] +
" - assigned unavailable course (spring): " +
section['course_name'], 3)
def create_user():
try:
data_j = json.loads(request.data)
username = data_j["username"]
test_password = data_j["test_password"]
random.seed()
token = str(random.random()) + username
db = get_db()
db.execute(
'INSERT INTO users (username, test_password)'
' VALUES (?, ?)', (username, test_password))
db.commit()
db.close()
return jsonify({'message': 'user added!'}), 200
create_log(request, username + " added to users")
except:
create_log(request,
"Error caught in create_user() located in admin.py")
def get_all_sections():
data_j = json.loads(request.data)
year = data_j['year']
token = data_j['token']
db = get_db()
if (admin.check_admin(token) == False):
db_sections = db.execute(
'SELECT id, course_id, section_number, instructor_id, instructor_name, sem, year, course_name, is_lab, token'
' FROM sections WHERE year = "' + year + '"' + ' AND token=' +
'"' + token + '"')
else:
db_sections = db.execute(
'SELECT id, course_id, section_number, instructor_id, instructor_name, sem, year, course_name, is_lab, token'
' FROM sections WHERE year = "' + year + '"')
desc = db_sections.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_sections.fetchall()]
return json.dumps(data)
def turn_instructors_to_objects(year, token):
instructor_objects = {}
db = get_db()
db_instructors = db.execute(
'SELECT name, net_id, rank, year, preps, wl_credits, wl_courses, summer, preferred_courses, available_courses'
' FROM instructors WHERE year = "' + year + '" AND token = "' + token +
'"')
desc = db_instructors.description
column_names = [col[0] for col in desc]
instructorsList = [
dict(zip(column_names, row)) for row in db_instructors.fetchall()
]
for i in instructorsList:
instructor_objects[i["net_id"]] = classes.Instructor(
i["net_id"], i["name"], i["year"], i["rank"], i["preps"],
i["wl_credits"], i["wl_courses"], i["summer"],
i["preferred_courses"], i["available_courses"])
return instructor_objects.values()
def add_course():
try:
data_j = json.loads(request.data)
course_id = data_j['course_id']
name = data_j['name']
owner = data_j['owner']
year = data_j['year']
freq_spr = data_j['freq_spr']
freq_sum1 = data_j['freq_sum1']
freq_sum2 = data_j['freq_sum2']
freq_fal = data_j['freq_fal']
freq_spr_l = data_j['freq_spr_l']
freq_sum1_l = data_j['freq_sum1_l']
freq_sum2_l = data_j['freq_sum2_l']
freq_fal_l = data_j['freq_fal_l']
token = data_j['token']
db = get_db()
db_courses = db.execute('SELECT course_id' ' FROM courses')
desc = db_courses.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_courses.fetchall()]
for i in data:
if (course_id == i['course_id']):
db.close()
return jsonify(
{'message': 'duplicate course, course not added'}), 200
db.execute(
'INSERT INTO courses (course_id, name, owner, year, freq_spr, freq_sum1, freq_sum2, freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l, owner, token)'
' VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)',
(course_id, name, owner, year, freq_spr, freq_sum1, freq_sum2,
freq_fal, freq_spr_l, freq_sum1_l, freq_sum2_l, freq_fal_l, owner,
token))
db.commit()
sections.create_sections(db, data_j, token)
db.close()
admin.create_log(request, course_id + " added to courses")
return jsonify({'message': 'course added'}), 200
except:
admin.create_log(request,
"Error caught in add_course() located in courses.py")
return jsonify({
'message':
'error encountered, please contact server administrator'
})
def login():
try:
db = get_db()
data_j = json.loads(request.data)
username = data_j["username"]
test_password = data_j["test_password"]
#Scan user login table for matching credentials
db_user = db.execute('SELECT username, token, default_year'
' FROM users WHERE (username = '******'"' +
username + '"' + ' AND test_password = '******'"' +
test_password + '")')
desc = db_user.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_user.fetchall()]
if (len(data) == 0):
# If no username/password match, return empty login
return jsonify({"username": "******", "test_password": "******"})
create_log(
request,
"Invalid user login attempted (No matching credentials)")
else:
ip = request.remote_addr
# Update user into login cache
update_login_cache(ip, data[0]["username"], data[0]["token"],
data[0]["default_year"])
admin.create_log(
request,
"User successfully logged in as " + data[0]["username"])
db.close()
return json.dumps(data[0])
except:
admin.create_log(request,
"Error caught in login() located in login.py")
return jsonify({
"message":
"Error logging in, please contact server administrators"
})
def create_warnings():
client_warnings = classes.Warnings()
client_warnings.clear()
db = get_db()
data_j = json.loads(request.data)
print('hi')
for instructor in json.loads(instructors.get_instructors()):
instructor_object = namedtuple("Instructor",
instructor.keys())(*instructor.values())
course_mismatch_warnings(client_warnings, instructor,
instructor_object, data_j)
sections_limit_warnings(client_warnings, instructor, instructor_object,
data_j)
preps_limit_warnings(client_warnings, instructor, instructor_object,
data_j)
for course in json.loads(courses.get_courses()):
course_object = namedtuple("Course", course.keys())(*course.values())
section_assignment_warnings(client_warnings, course, course_object,
data_j)
return client_warnings
def delete_course():
try:
data_j = json.loads(request.data)
token = data_j['token']
course_id = data_j['course_id']
db = get_db()
db.execute('DELETE FROM courses WHERE (course_id = ' + '"' +
course_id + '"' + ' AND token = ' + '"' + token + '")')
db.execute('DELETE FROM sections WHERE (course_id = ' + '"' +
course_id + '"' + ' AND token = ' + '"' + token + '")')
db.commit()
db.close()
admin.create_log(request, course_id + " deleted from courses")
return jsonify({'message': 'course deleted'}), 200
except:
admin.create_log(
request, "Error caught in delete_course() located in courses.py")
return jsonify({
'message':
'error encountered, please contact server administrator'
})
def get_instructor():
data_j = json.loads(request.data)
net_id = data_j['net_id']
year = data_j['year']
token = data_j['token']
db = get_db()
if (admin.check_admin(token) == False):
db_instructor = db.execute(
'SELECT name, net_id, preps, rank, wl_credits, wl_courses, summer, preferred_courses, available_courses, year, owner, token'
' FROM instructors WHERE (net_id = ' + '"' + net_id + '"' +
' AND year = ' + '"' + year + '"' + ' AND token = ' + '"' + token +
'")')
else:
db_instructor = db.execute(
'SELECT name, net_id, preps, rank, wl_credits, wl_courses, summer, preferred_courses, available_courses, year, owner, token'
' FROM instructors WHERE (net_id = ' + '"' + net_id + '"' +
' AND year = ' + '"' + year + '")')
desc = db_instructor.description
column_names = [col[0] for col in desc]
data = [dict(zip(column_names, row)) for row in db_instructor.fetchall()]
return json.dumps(data[0])
def preps_limit_warnings(client_warnings, instructor, instructor_object,
data_j):
db = get_db()
course_list_spr = []
course_list_fal = []
for section in get_instructor_sections(instructor['net_id'],
data_j['year'], data_j['token']):
if section["sem"] == "Spr":
course_list_spr.append(section['course_name'])
if section["sem"] == "Fal":
course_list_fal.append(section['course_name'])
course_list_spr = list(set(course_list_spr))
course_list_fal = list(set(course_list_fal))
if (len(course_list_spr) > int(instructor['preps'])):
client_warnings.generate(
instructor_object, instructor["name"] +
" - assigned too many unique classes (spring)", 1)
if (len(course_list_fal) > int(instructor['preps'])):
client_warnings.generate(
instructor_object,
instructor["name"] + " - assigned too many unique classes (fall)",
1)
