def put(request):
req = request.data
if len(req) == 4:
try:
bid = req['bid']
text = req['text']
score = req['score']
student_id = req['student_id']
except KeyError:
raise ArgumentError()
if not 1 <= score <= 5:
raise ArgumentError(detail="评分只能为1-5分")
try:
student = Student.objects.get(id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
try:
course = Course.objects.get(bid=bid)
except Course.DoesNotExist:
raise NotFoundError(detail="没有这门课程")
try:
evaluation = CourseEvaluation.objects.get(student=student,
course=course)
evaluation.evaluation = text
evaluation.score = score
except CourseEvaluation.DoesNotExist:
evaluation = CourseEvaluation(student=student,
course=course,
score=score,
evaluation=text)
evaluation.save()
return HttpResponse(status=201)
raise ArgumentError()
def get(request):
# 记录次数
try:
count = RequestRecord.objects.get(name='score')
except RequestRecord.DoesNotExist:
count = RequestRecord(name='score', count=0)
count.count += 1
count.save()
# 查询
req = request.query_params.dict()
result = Score.objects.all()
if len(req) == 2:
for key, value in req.items():
if key == 'semester':
result = result.filter(semester=value)
elif key == 'student_id':
# 检查学生是否存在
try:
Student.objects.get(id=req['student_id'])
except Student.DoesNotExist:
raise UnAuthorizedError()
result = result.filter(student_id=value)
else:
raise ArgumentError()
else:
raise ArgumentError()
score_serializer = ScoreSerializer(result, many=True)
return Response(score_serializer.data)
def get(request):
"""
管理员调用获得用户反馈信息
http://127.0.0.1:8000/feedback/
http://127.0.0.1:8000/feedback/?date=2020-05-14
http://127.0.0.1:8000/feedback/?kind=bug
无参数或参数插入日期或反馈类别
返回结果:学生id，插入日期，反馈类别，具体内容
:param request:
:return:
"""
req = request.query_params.dict()
if (len(req) != 1) & (len(req) != 0):
raise ArgumentError()
result = []
if "date" in req:
result = Feedback.objects.filter(date__contains=req["date"])
elif "kind" in req:
result = Feedback.objects.filter(kind=req["kind"])
elif len(req) == 0:
result = Feedback.objects.all()
else:
raise ArgumentError()
content = []
for i in result:
name = i.student_id.name
content.append({"name": name, "date": i.date, "kind": i.kind, "content": i.content})
return Response(content)
def get(request):
"""
根据学号返回该学生的所有功能更新时间
访问方法
GET
http://127.0.0.1:8000/spider/update/?student_id=17373349 某个学生的所有功能更新时间
http://127.0.0.1:8000/spider/update/?calendar=1 校历
http://127.0.0.1:8000/spider/update/?empty_room=1 空教室
:param request:
:return:
"""
req = request.query_params.dict()
if len(req) != 1:
raise ArgumentError()
content = {}
if "student_id" in req:
try:
student = Student.objects.get(id=req["student_id"])
content = PostRecord.objects.filter(student_id=student).values(
"name", "time")
except Student.DoesNotExist:
raise UnAuthorizedError
elif ("calendar" in req) and (req["calendar"] == "1"):
content = PostRecord.objects.filter(name="calendar").values(
"name", "time")
elif ("empty_room" in req) and (req["empty_room"] == "1"):
content = PostRecord.objects.filter(name="empty_room").values(
"name", "time")
else:
raise ArgumentError
return Response(content)
def default(request):
req = request.query_params.dict()
teacher_courses = []
if 'student_id' in req.keys():
output = {}
student_id = req['student_id']
try:
student = Student.objects.get(id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
courses = StudentCourse.objects.filter(student_id=student)
for course in courses:
select_course = course.course_id
teacher_course = TeacherCourse.objects.filter(
course_id=select_course)[0]
teacher_courses.append(teacher_course)
result = TeacherCourseSerializer(teacher_courses, many=True).data
info = format_search(result)
total = len(info)
output['total'] = total
output['cur_page'] = 1
output['total_page'] = 1
output['info'] = info
return Response(output)
raise ArgumentError()
def get(request):
"""
输入：校区，日期，第几节到第几节，返回：教学楼，教室
参数1:校区 e.g. 新主楼
参数2：日期 e.g. 2020-4-18
参数3：第几节到第几节 e.g. 1,2,3,
例:http://114.115.208.32:8000/classroom/?campus=学院路校区&date=2020-04-20§ion=1, 2, 3,
返回:查询结果
没有提供参数，参数数量错误，返回400错误;
参数错误，返回400错误;
"""
try: # 保存前端请求数据
record = RequestRecord.objects.get(name="classroom")
record.count = record.count + 1
record.save()
except RequestRecord.DoesNotExist:
RequestRecord(name="classroom", count=1).save()
req = request.query_params.dict()
if (len(req) != 3) | ("campus" not in req) | ("date" not in req) | ("section" not in req):
raise ArgumentError()
campus = req["campus"]
date = req["date"]
section = req["section"]
content = {}
req = Classroom.objects.filter(campus=campus, date=date, section__contains=section)
tb_re = req.values("teaching_building").distinct()
for i in tb_re:
cr_re = req.filter(teaching_building=i["teaching_building"]).values("classroom").distinct()
content.update({i["teaching_building"]: cr_re})
return Response(content)
def get(request):
"""
功能：前端获取校历和该学生未完成的ddl
调用方法：http://127.0.0.1:8000/ddl/Calendar/?student_id=17373349&school_year=2019-2020
返回参数：具体学期，日期，节假日，ddl事件
具体json格式见接口文档，两个列表，一个ddl，一个节假日
:param request:
:return:
"""
try: # 保存前端请求数据
record = RequestRecord.objects.get(name="SchoolCalendar")
record.count = record.count + 1
record.save()
except RequestRecord.DoesNotExist:
RequestRecord(name="SchoolCalendar", count=1).save()
req = request.query_params.dict()
if (len(req) != 2) or ("student_id" not in req) or ("school_year"
not in req):
raise ArgumentError()
try:
Student.objects.get(id=req['student_id'])
ddl_req = DDL.objects.filter(student_id=req['student_id'])
except Student.DoesNotExist:
raise UnAuthorizedError()
# 该学生未完成的ddl
ddl = ddl_req.filter((Q(state="尚未提交") | Q(state="草稿 - 进行中"))).values(
"course", "homework", "ddl")
# 第一学期开始日期+寒假开始日期+第二学期开始日期+第三学期开始日期
try:
semester = SchoolYear.objects.get(school_year=req["school_year"])
except SchoolYear.DoesNotExist:
raise DatabaseNotExitError
# 节假日信息
holiday = SchoolCalendar.objects.filter(
Q(semester__contains=req["school_year"])
& ~Q(holiday__contains=req["school_year"]))
content = {
"school_year": req["school_year"],
"first_semester": semester.first_semester,
"winter_semester": semester.winter_semester,
"second_semester": semester.second_semester,
"third_semester": semester.third_semester,
"end_semester": semester.end_semester
}
content.update({
"holiday":
holiday.values("year", "semester", "date", "holiday"),
"ddl":
ddl
})
return Response(content)
def post(request): #
"""
访问方法 POST http://127.0.0.1:8000/classroom/
数据格式
{
"date":"2020-04-20",
"classroom":[
{
"campus":"学院路校区",
"teaching_building":"一号楼",
"classroom":"(一)203",
"section":"1,2,3,4,5,7,"
}
]
}
输出：HTTP状态码，错误为500
正确，{"state":1}
"""
req = request.data
Classroom.objects.filter(date=req['date']).delete()
try: # 学生更新数据最新时间
PostRecord.objects.get(name="empty_room").delete()
PostRecord.objects.get(name="empty_room").save()
except PostRecord.DoesNotExist:
PostRecord(name="empty_room").save()
if "classroom" not in req:
raise ArgumentError()
for key in req["classroom"]:
Classroom(campus=key["campus"], teaching_building=key["teaching_building"],
classroom=key["classroom"], date=req["date"], section=key["section"]).save()
content = {"state": 1}
return Response(content)
def delete(request):
req = request.data
if 'ack' in req.keys() and req['ack'] == "sure":
course = Course.objects.all()
teacher = Teacher.objects.all()
public_course = PublicCourse.objects.all()
course.delete()
teacher.delete()
public_course.delete()
return HttpResponse(status=204)
raise ArgumentError(detail=None)
def get(request):
start_day = '2020-2-24'
req = request.query_params.dict()
result = StudentCourse.objects.all()
# 记录查询次数
try:
count = RequestRecord.objects.get(name='timetable')
except RequestRecord.DoesNotExist:
count = RequestRecord(name='timetable', count=0)
count.count += 1
count.save()
# 课表查询请求
if len(req) == 2:
for key, value in req.items():
if key == 'student_id':
try:
Student.objects.get(id=req['student_id'])
except Student.DoesNotExist:
raise UnAuthorizedError()
result = result.filter(student_id__id=value)
elif key == 'week':
if value != 'all':
value += ','
result = result.filter(week__icontains=value)
else:
raise ArgumentError()
course_serializer = StudentCourseSerializer(result, many=True)
return Response(course_serializer.data)
# 当前周查询请求
if len(req) == 1:
if 'date' in req.keys():
content = []
date1 = datetime.strptime(req['date'], "%Y-%m-%d")
date2 = datetime.strptime(start_day, "%Y-%m-%d")
total_week = min(16, int((date1 - date2).days / 7 + 1))
value = str(total_week)
content.append({"week": value})
return Response(content)
raise ArgumentError()
# 其他非法请求
raise ArgumentError()
def post(request):
"""
pm调用在数据库中插入最新版本信息
访问方法 http://127.0.0.1:8000/version/
参数:版本号，更新日期，更新公告，下载地址
返回结果：插入状态
"""
req = request.data
if (len(req) != 4) | (("version_number" not in req) | ("update_date" not in req) |
("announcement" not in req) | ("download_address" not in req)):
raise ArgumentError()
if len(VERSION.objects.filter(version_number=req["version_number"])) > 0:
raise ArgumentError()
VERSION(version_number=req["version_number"], update_date=req["update_date"],
announcement=req["announcement"],
download_address=req["download_address"]).save()
return Response({"state": "成功"})
def cancel_down_action(request):
req = request.data
if len(req) == 3:
actor, evaluation = get_evaluation(req)
try:
down = EvaluationDownRecord.objects.get(evaluation=evaluation,
student=actor)
down.delete()
up_cnt = up_count(evaluation)
down_cnt = down_count(evaluation)
return Response({"up": up_cnt, "down": down_cnt}, status=201)
except EvaluationDownRecord.DoesNotExist:
raise NotFoundError(detail="不存在这条被踩记录")
raise ArgumentError()
def get(request):
req = request.query_params.dict()
result = CourseEvaluation.objects.all()
teachers = TeacherCourse.objects.all()
info_dict = {}
if len(req) == 2:
try:
bid = req['bid']
student_id = req['student_id']
except KeyError:
raise ArgumentError()
try:
student = Student.objects.get(id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
try:
course = Course.objects.get(bid=bid)
except Course.DoesNotExist:
raise NotFoundError(detail="没有这门课程")
result = result.filter(course__bid=bid)
teachers = teachers.filter(course_id__bid=bid)
teacher_info = TeacherEvaluationSerializer(teachers,
many=True).data
teacher_info = format_serializer_teacher(teacher_info, student)
info = CourseEvaluationSerializer(result, many=True).data
info = format_serializer(info, student)
avg_score = result.aggregate(Avg('score'))['score__avg']
avg_score = 0.0 if avg_score is None else round(avg_score, 1)
evaluation_num = evaluator_count(course)
info_dict["course_name"] = course.name
info_dict["evaluation_num"] = evaluation_num
info_dict["avg_score"] = avg_score
info_dict["teacher_info"] = teacher_info
info_dict["info"] = info
info_dict["score_info"] = get_score_info(course)
return Response(info_dict)
raise ArgumentError()
def get(request):
req = request.query_params.dict()
result = TeacherCourse.objects.all()
if 1 <= len(req) <= 5:
page = 1
output = {}
for key, value in req.items():
if value == "":
continue
if key == 'course':
name = req['course']
result = result.filter(course_id__name__icontains=name)
elif key == 'teacher':
name = req['teacher']
result = result.filter(teacher_id__name__icontains=name)
elif key == 'type':
types = req['type']
result = result.filter(course_id__type=types)
elif key == 'department':
department = req['department']
result = result.filter(course_id__department=department)
elif key == 'page':
page = int(req['page'])
else:
raise ArgumentError()
results = TeacherCourseSerializer(result, many=True).data
result = format_search(results)
total = len(result)
start = 30 * (page - 1)
end = min(page * 30, total)
result = result[start:end]
output['total'] = total
output['cur_page'] = page
output['total_page'] = max(1, math.ceil(total / 30))
output['info'] = result
return Response(output)
raise ArgumentError()
def post(request):
req = request.data
if len(req) == 4:
teacher_name = req['teacher']
bid = req['bid']
actor = req['actor']
action = req['action']
try:
teacher = Teacher.objects.get(name=teacher_name)
except Teacher.DoesNotExist:
raise NotFoundError(detail="没有这个老师")
try:
course = Course.objects.get(bid=bid)
except Course.DoesNotExist:
raise NotFoundError(detail="没有这门课程")
try:
student = Student.objects.get(id=actor)
except Student.DoesNotExist:
raise UnAuthorizedError()
try:
teacher_course = TeacherCourse.objects.get(teacher_id=teacher,
course_id=course)
except TeacherCourse.DoesNotExist:
raise NotFoundError(detail="没有这个课程评价")
if action == 'up':
try:
# 已经点过赞
TeacherEvaluationRecord.objects.get(
teacher_course=teacher_course, student=student)
return Response({"up": teacher_course.up}, status=202)
except TeacherEvaluationRecord.DoesNotExist:
# 没点过赞
up_record = TeacherEvaluationRecord(
teacher_course=teacher_course, student=student)
up_record.save()
teacher_course.up = up_count_teacher(teacher_course)
teacher_course.save()
return Response({"up": teacher_course.up}, status=201)
if action == 'cancel_up':
try:
up_record = TeacherEvaluationRecord.objects.get(
teacher_course=teacher_course, student=student)
up_record.delete()
teacher_course.up = up_count_teacher(teacher_course)
teacher_course.save()
except TeacherEvaluationRecord.DoesNotExist:
raise NotFoundError(detail="不存在这个点赞记录")
return Response({"up": teacher_course.up}, status=201)
raise ArgumentError()
def post(request):
req = request.data
# 确保数据库中有此学生的记录
try:
student = Student.objects.get(id=req['student_id'])
except Student.DoesNotExist:
raise UnAuthorizedError()
# 爬虫的数据库插入请求
if len(req) == 3:
semester = req['semester']
for key in req['info']:
insert_score(student=student, semester=semester, key=key)
return HttpResponse(status=201)
# 其他非法请求
raise ArgumentError()
def delete(request):
req = request.data
if len(req) == 2:
try:
bid = req['bid']
student_id = req['student_id']
except KeyError:
raise ArgumentError()
try:
student = Student.objects.get(id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
try:
course = Course.objects.get(bid=bid)
except Course.DoesNotExist:
raise NotFoundError(detail="没有这门课程")
try:
evaluation = CourseEvaluation.objects.get(student=student,
course=course)
evaluation.delete()
return HttpResponse(status=204)
except CourseEvaluation.DoesNotExist:
raise NotFoundError(detail="没有这条评价")
raise ArgumentError()
def add_student_course(student, semester, info):
if len(info) == 6:
bid = info[0].replace(' ', '')
name = info[1].replace(' ', '')
name, bid = check_public(name, bid)
place = info[2].replace(' ', '')
teacher = info[3].replace(' ', '')
week = info[4].replace(' ', '')
time = info[5]
# 获取课程信息
try:
course = Course.objects.get(bid=bid)
if len(name) <= len(course.name):
course.name = name
course.save()
except Course.DoesNotExist:
if name.find('体育') != -1:
course = Course(bid=bid,
name=name,
credit=0.5,
hours=16,
department='体育部',
type='体育类')
else:
course = Course(bid=bid, name=name)
course.save()
# 保存信息
new_student_course = StudentCourse(student_id=student,
course_id=course,
week=split_week(week),
time=split_time(time),
place=place,
semester=semester)
new_student_course.save()
# 增加教师信息
teachers = teacher.split(',')
# 一门课程可能有多个教师
for key in teachers:
teacher = add_teacher(key)
# 增加总课的关联关系
add_teacher_relation(teacher, course)
# 增加这节课的关联关系
relation = TeacherCourseSpecific(
student_course_id=new_student_course, teacher_id=teacher)
relation.save()
return HttpResponse(status=201)
# 不是5项表示数据有缺失
raise ArgumentError()
def add_course(request):
req = request.data
if 'info' in req.keys():
for info in req['info']:
if info[0].find('体育') != -1:
continue
course = add_course(info)
teacher_list = info[6]
teachers = teacher_list.split(',')
for teacher_name in teachers:
teacher_name = teacher_name.replace(' ', '')
if teacher_name == "":
continue
teacher = add_teacher(teacher_name)
add_teacher_relation(teacher, course)
return HttpResponse(status=201)
raise ArgumentError()
def get(request):
"""
输入：学号，输出：作业，dll，提交状态，课程
参数1:学生学号 e.g. 17373349
例:http://127.0.0.1:8000/ddl/?student_id=17373349
返回作业，dll，提交状态，课程
没有提供参数，参数数量错误，返回500错误;
参数错误，返回400错误;
查询用户不存在返回401
"""
try: # 保存前端请求数据
record = RequestRecord.objects.get(name="ddl")
record.count = record.count + 1
record.save()
except RequestRecord.DoesNotExist:
RequestRecord(name="ddl", count=1).save()
req = request.query_params.dict()
if (len(req) != 1) or ("student_id" not in req):
raise ArgumentError()
student_id = req["student_id"]
content = []
try:
Student.objects.get(id=req['student_id'])
req = DDL.objects.filter(student_id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
course_re = req.values("course").distinct()
for i in course_re:
cr_re_1 = req.filter(
Q(course=i["course"])
& (Q(state="尚未提交") | Q(state="草稿 - 进行中"))).values(
"homework", "ddl", "state").distinct()
cr_re_2 = req.filter(
Q(course=i["course"])
& (~Q(state="尚未提交") & ~Q(state="草稿 - 进行中"))).values(
"homework", "ddl", "state").distinct()
cr_re = chain(cr_re_1, cr_re_2)
content.append({"name": i["course"], "content": cr_re})
return Response(content)
def get(request):
req = request.query_params.dict()
student_id = req['student_id']
score_sum = 0.0
credit_sum = 0.0
try:
Student.objects.get(id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
if len(req) == 1 and 'student_id' in req.keys():
scores = Score.objects.filter(student_id=student_id)
for score in scores:
score_sum += score.score * score.credit
credit_sum += score.credit
if credit_sum == 0:
return Response({'score': 0.00000})
return Response({'score': score_sum / credit_sum})
raise ArgumentError()
def get(request):
"""
前端调用得到最新版本信息
访问方法 http://127.0.0.1:8000/version/
无参数
返回结果：版本号，更新日期，更新公告，下载地址
"""
req = request.query_params.dict()
if len(req) != 0:
raise ArgumentError()
data = VERSION.objects.all()
length = data.count()
if length > 0:
return Response(
data.values("version_number", "update_date", "announcement", "download_address")[length - 1])
return Response({"version_number": "", "update_date": "", "announcement": "", "download_address": ""})
def post(request):
# 爬虫执行完成时返回完成的request id
req = request.data
if len(req) == 1 and 'req_id' in req.keys():
cur_id = int(req['req_id'])
try:
PENDING_WORK.remove(cur_id)
except ValueError:
raise NotFoundError(detail='没有这个任务号')
return HttpResponse(status=200)
if len(req) == 4:
REQ_QUEUE.append(req)
log = open('log.txt', 'a')
log.write('new request: ')
log.write(str(req))
log.write('\n')
PENDING_WORK.append(req['req_id'])
return HttpResponse(status=201)
raise ArgumentError()
def get(request):
req = request.query_params.dict()
# 爬虫在这里取得request
if not req:
if not REQ_QUEUE:
return HttpResponse(status=204)
cur_queue = REQ_QUEUE.pop(0)
log = open('log.txt', 'a')
log.write('request has been sent: ')
log.write(str(cur_queue))
log.write('\n')
return Response(cur_queue)
# 前端在这里取得对应任务是否完成的信息, true为已完成
if len(req) == 1 and 'id' in req:
return Response([{'status': int(req['id']) not in PENDING_WORK}])
# 其他非法请求
raise ArgumentError()
def get(request):
req = request.query_params.dict()
student_id = req['student_id']
gpa_sum = 0.0
credit_sum = 0.0
try:
Student.objects.get(id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
if len(req) == 1 and 'student_id' in req.keys():
scores = Score.objects.filter(student_id=student_id)
for score in scores:
if score.origin_score != '通过' and score.origin_score != '不通过':
gpa_sum += get_gpa(score.origin_score, score.credit)
credit_sum += score.credit
if credit_sum == 0:
return Response({'gpa': 0.0000})
return Response({'gpa': gpa_sum / credit_sum})
raise ArgumentError()
def post(request):
"""
前端调用插入用户反馈信息
http://127.0.0.1:8000/feedback/
参数:学生id，反馈类别，具体内容
:param request:
:return:
"""
req = request.data
if (len(req) != 3) | (("student_id" not in req) |
("kind" not in req) | ("content" not in req)):
raise ArgumentError()
try:
student = Student.objects.get(id=req['student_id'])
except Student.DoesNotExist:
raise UnAuthorizedError()
Feedback(student_id=student, kind=req["kind"], content=req["content"]).save()
return Response({"state": "成功"})
def insert_score(student, semester, key):
if len(key) == 6:
bid = key[0].replace(' ', '')
course_name = key[1]
credit = key[2].replace(' ', '')
label = key[3].replace(' ', '')
origin_score = key[4].replace(' ', '')
score = key[5].replace(' ', '')
if origin_score == '缓考':
return
try:
old_score = Score.objects.get(student_id=student, bid=bid)
if label == '补考':
insert_failed_course(old_score=old_score,
semester=semester,
label=label,
origin_score=origin_score,
score=score)
elif label == '重修':
old_score.label = label
old_score.origin_score = origin_score
old_score.score = score
old_score.semester = semester
old_score.save()
else:
old_score.origin_score = origin_score
old_score.score = score
old_score.save()
except Score.DoesNotExist:
new_score = Score(student_id=student,
semester=semester,
course_name=course_name,
bid=bid,
credit=credit,
label=label,
origin_score=origin_score,
score=score)
new_score.save()
return
raise ArgumentError()
def post(request):
"""
根据学号删除某个学生的信息，且在消息队列中删除该学生的请求
访问方法 POST http://127.0.0.1:8000/spider/delete/
参数usr_name, password, error_type
如果数据库中无该学生，返回0
如果数据库中密码不相同，返回-1
如果成功删除返回1
"""
req = request.data
if (len(req) != 3) | ("usr_name" not in req) | (
"password" not in req) | ("error_type" not in req):
raise ArgumentError()
max_error = 2 #账号密码错误允许次数
number = 1
if req["error_type"] == 1: #账号被锁
number = max_error
state = 0
try:
student = Student.objects.get(usr_name=req["usr_name"])
if student.usr_password != req["password"]:
state = -1
else:
try:
ste = StudentError.objects.get(student_id=student.id)
except StudentError.DoesNotExist:
ste = StudentError(student_id=student)
ste.save()
ste.number = ste.number + number
ste.save()
if ste.number >= max_error:
student.delete()
delete_request(student.usr_name, student.usr_password)
state = 1
except Student.DoesNotExist:
raise UnAuthorizedError
content = {"state": state}
return Response(content)
def get_evaluation(req):
try:
student_id = req['student_id']
actor = req['actor']
bid = req['bid']
except KeyError:
raise ArgumentError()
try:
student = Student.objects.get(id=student_id)
actor = Student.objects.get(id=actor)
except Student.DoesNotExist:
raise UnAuthorizedError()
try:
course = Course.objects.get(bid=bid)
except Course.DoesNotExist:
raise NotFoundError(detail="没有这门课程")
try:
evaluation = CourseEvaluation.objects.get(student=student,
course=course)
except CourseEvaluation.DoesNotExist:
raise NotFoundError(detail="没有这条评价")
return actor, evaluation
def post(request):
"""
根据post的json文件来将相关数据插入数据库；
格式：{student_id:(id), semester:(sm), info:[[课程名称1,地点1...],[课程名称2,地点2...]}
"""
req = request.data
# 确保数据库中有这个同学的信息
student_id = req['student_id']
try:
student = Student.objects.get(id=student_id)
except Student.DoesNotExist:
raise UnAuthorizedError()
# 爬虫的数据库插入请求
if len(req) == 2:
semester = '2020_Spring'
# 更新则默认将原记录删除
StudentCourse.objects.filter(student_id=student_id).delete()
# 将爬虫爬取的数据写入数据库
for lists in req['info']:
for info in lists:
add_student_course(student, semester, info)
return HttpResponse(status=201)
# 其他非法请求
raise ArgumentError()
