def add_single_std():
try:
data = request.get_json()
user_id = int(data.get("user_id"))
class_id = int(data.get("class_id"))
# 用户账号
account = data.get("account")
# 用户名
username = data.get("username")
user = User.query.filter_by(id=user_id).first()
if not user.is_teacher:
return responseError(Responses.AUTHORIZATION_ERROR)
classes = Class.query.get(class_id)
u = User.query.filter_by(account=account, username=username)
# 若要添加的学生不存在则添加进User表后再加入班级
if u is None:
new_user = User(account=account, username=username)
# 初始密码可设置
new_user.set_password("2020")
db.session.add(new_user)
# 先插入用户
db.session.commit()
found_user = User.query.filter_by(account=account,
username=username)
# 在加入班级关联
classes.stds.append(found_user)
db.session.commit()
else:
classes.stds.append(u)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def get_work():
try:
data = request.get_json()
assignment_id = int(data.get("assignment_id"))
assign = Assignment.query.get(assignment_id)
if assign is None:
return responseError(Responses.NO_RECORD_FOUND)
work_img_path = "47.96.231.121/works/" + assign.content
with open(work_img_path, 'rb') as f:
stream = base64.b64encode(f.read())
work_base64_str = str(stream, encoding='utf-8')
return responseBody(data=work_base64_str)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def del_fc():
try:
data = request.get_json()
# fc_id 是 1-XX 的形式
# 获得要删除的章节的id
fc_id = data.get("fc_id")
fc_id = int(fc_id.split("-")[1])
fc = FirstCategory.query.get(fc_id)
# 如果该章节是第一章
if fc.is_first_category:
# 若总共只有一章则什么也不做
if fc.next_category_id != 0:
# 否则该章节的下一章设为链表头
next_fc = FirstCategory.query.get(fc.next_category_id)
next_fc.is_first_category = True
# 如果该章节不是第一章
else:
# 找到该章节的上一章
pre_fc = FirstCategory.query.filter_by(
next_category_id=fc.id).first()
# 上一章的指针指向要删除的章节的下一章
pre_fc.next_category_id = fc.next_category_id
# 删除章节
db.session.delete(fc)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def create_sc():
try:
data = request.get_json()
title = data.get("title")
# 接受视频文件
movie_file = request.files.get("file")
# 生成随机文件名
filename = random_filename(movie_file.filename)
# 生成文件保存路径
save_path = '/%s' % filename
# 保存文件
movie_file.save(save_path)
# 该视频属于的大章节
fc_id = data.get("fc_id")
fc_id = int(fc_id.split("-")[1])
# 构造二级目录
new_sc = SecondCategory(name=title,
parent_category_id=fc_id,
movie=save_path)
db.session.add(new_sc)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def submit_work():
try:
data = request.get_json()
# 提交用户
user_id = int(data.get("user_id"))
# 作业id
assignment_id = int(data.get("assignment_id"))
# 提交内容
content = data.get("content")
# 如果要判断答案，则先找到Assignment对象，然后获取answer，与用户的提交内容选择题部分判断
# 然后把分数加到score
# 查看是否已存在提交记录
fs = FinishStatus.query.filter_by(assignment_id=assignment_id,
finish_user_id=user_id).first()
if fs is not None:
# 存在提交记录则更新内容和提交时间
fs.finish_content = content
fs.finish_time = datetime.datetime.utcnow
else:
# 否则构造提交记录并插入
fs = FinishStatus(assignment_id=assignment_id,
finish_user_id=user_id,
finish_content=content)
db.session.add(fs)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def get_unread():
data = request.get_json()
try:
user_id = int(data.get("user_id"))
user = User.query.get(user_id)
# 未读课程和未读作业个数
unread_classes = []
unread_assignment_count = 0
# 用户的所有班级
classes = user.user_classes
for c in classes:
classes_read = CourseRead.query.filter_by(class_id=c.id).first()
if classes_read is not None:
cIds_str = classes_read.readed_std_ids
# id不再里面表示该课程未读
if str(user.id) not in cIds_str.split("|"):
unread_classes.append({"name": c.class_name})
# 该课程的作业
assignments = c.assignments
for a in assignments:
assignment_read = AssignmentRead.query.filter_by(
assignment_id=a.id).first()
aIds_str = assignment_read.readed_std_ids
if str(a.id) not in aIds_str.split("|"):
unread_assignment_count += 1
response_info = {
"readingClassNum": len(unread_classes),
"classNameList": unread_classes,
"messageNum": unread_assignment_count
}
return responseBody(data=response_info)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def get_talking():
try:
data = request.get_json()
class_id = int(data.get("class_id"))
c = Class.query.get(class_id)
talkings = Talkings.query.with_parent(c).order_by(
Talkings.publish_time.desc()).all()
response_info = []
for t in talkings:
cs = Comments.query.with_parent(t).filter_by(
is_reply=False).count()
response_info.append({
"id":
t.id,
"title":
t.title,
"content":
t.content,
"userName":
t.publish_user.username,
"date":
datetime.datetime.strftime(t.publish_time,
"%Y-%m-%d %H:%M:%S"),
"replyNum":
cs
})
return responseBody(data=response_info)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def get_replies():
try:
data = request.get_json()
# comment_id为要查看的某条评论/回复 的id
comment_id = int(data.get("comment_id"))
Mes = Comments.query.filter_by(id=comment_id).first()
# 获取这条评论/回复的所有回复，每个回复是一个Comment对象
replies = Mes.replies
Message = []
for index, c in enumerate(replies):
Message.append({
# index为评论编号,从0开始
"index":
index,
"comment_id":
c.id,
"user_id":
c.from_user_id,
"content":
c.content,
"userName":
User.query.filter_by(id=c.from_user_id).first().username,
"date":
datetime.datetime.strftime(c.send_time, '%Y-%m-%d %H:%M:%S')
})
return responseBody(data=Message)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def submit_work():
try:
data = request.get_json()
title = data.get("title")
sc_id = data.get("sc_id")
# 获取选择题答案
answer = data.get("answer")
sc_id = int(sc_id.split("-")[1])
# 要上传的作业图片base64编码
work_img_base64 = data.get("work_img")
work_id = max([a.id for a in Assignment.query.all()]) + 1
work_path = '/py3env/West2/West2OlineWork/static/works/%s.jpg' % str(
work_id)
with open(work_path, 'wb') as w:
w.write(base64.b64decode(work_img_base64))
# 获得修改后的头像的base64编码
with open(work_path, 'rb') as f:
stream = base64.b64encode(f.read())
work_base64_str = str(stream, encoding='utf-8')
assignment = Assignment(title=title,
content=work_path,
belong_category_id=sc_id,
answer=answer)
db.session.add(assignment)
db.session.commit()
return responseBody(data=[{"work_img": work_base64_str}])
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def get_assignment_submit():
try:
# 可以一次性获得所有，也可以只获取一个
data = request.get_json()
assignment_id = int(data.get("assignment_id"))
# index表示要获取第几个提交内容,若不传则获取所有
require_index = data.get("index")
assign = Assignment.query.get(assignment_id)
# 先获取到所有提交内容
fss = assign.finish_status
response_info = []
temp = {"total_num": len(fss)}
if require_index is None:
# 提交总数
details = []
for fs in fss:
details.append({
"id": fs.id,
"from_user": fs.finish_user.username,
"content": fs.finish_content
})
temp["details"] = details
else:
# 获取单个,index从0开始
single_fs = fss[int(require_index)]
temp["detail"] = {
"id": single_fs.id,
"from_user": single_fs.finish_user.username,
"content": single_fs.finish_content
}
response_info.append(temp)
return responseBody(data=response_info)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def get_comments():
try:
data = request.get_json()
talkings_id = int(data.get("talking_id"))
comments = Comments.query.filter_by(
belong_talking_id=talkings_id,
is_reply=False).order_by(Comments.send_time.desc()).all()
Message = []
for index, c in enumerate(comments):
Message.append({
"index":
index,
"comment_id":
c.id,
"content":
c.content,
"userName":
User.query.filter_by(id=c.from_user_id).first().username,
"reply_num":
len(c.replies),
"date":
datetime.datetime.strftime(c.send_time, '%Y-%m-%d %H:%M:%S')
})
return responseBody(data=Message)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def get_statistical_data():
try:
data = request.get_json()
assignment_id = int(data.get("assignment_id"))
assign = Assignment.query.get(assignment_id)
# 获取该作业的所有完成情况
fss = assign.finish_status
score_list = []
max_score = 0
min_score = 0
avg_score = 0.0
if len(score_list) != 0:
for fs in fss:
score_list.append(fs.score)
max_score = max(score_list)
min_score = min(score_list)
avg_score = sum(score_list) / len(score_list)
return responseBody(data=[{
"avg_score": round(avg_score, 2),
"min_score": min_score,
"max_score": max_score
}])
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def update_face():
try:
user_data = request.get_json()
user_id = int(user_data.get("user_id"))
user_face = user_data.get("user_face")
file_type = user_data.get("type")
user = User.query.filter_by(id=user_id).first()
user_avatar = "default.jpg"
if user.avatar != "default":
user_avatar = "%s.%s" % (user.username, file_type)
avatar_filename = random_filename(user_avatar)
user.avatar = avatar_filename
db.session.commit()
avatar_path = '/py3env/West2/West2OlineWork/static/avatars/%s' % avatar_filename
Users = []
# 写入图片并保存
with open(avatar_path, 'wb') as w:
w.write(base64.b64decode(user_face[23:]))
# 获得修改后的头像的base64编码
with open(avatar_path, 'rb') as f:
stream = base64.b64encode(f.read())
avatar_base64_str = str(stream, encoding='utf-8')
Users.append({
"user_name": user.username,
"avatar": avatar_base64_str,
"type": file_type,
"total_study": user.total_study
})
return responseBody(data=Users)
except Exception as e:
print(e)
db.session.commit()
return responseError(Responses.PARAMETERS_ERROR)
def create_first_category():
try:
data = request.get_json()
class_id = int(data.get("class_id"))
title = data.get("title")
# 若before为"front"，则在最前加入
# 若before不为空，则在指定位置后插入
# 若before为"last",则在最后加入
before = data.get("before")
user_class = Class.query.get(class_id)
# 要插入的章节的id
new_fc_id = max([c.id for c in FirstCategory.query.all()]) + 1
# 在最前面加入
if before.strip() == "front":
next_id = 0
# 判断该班级是否已存在章节
fc = FirstCategory.query.with_parent(user_class).filter_by(
is_first_category=True).first()
if fc is not None:
# 存在已有章节，则插到最前
# 修改第一个章节
fc.is_first_category = False
next_id = fc.id
# 若不存在已有章节，则该章节的next章节id为0
# 构造章节加入,该章节为第一章,下一章为原先的第一章
new_fc = FirstCategory(name=title,
belong_class_id=class_id,
next_category_id=next_id,
is_first_category=True)
elif before.strip() == "last":
# 找到最后一个章节
lc = FirstCategory.query.with_parent(user_class).filter_by(
next_category_id=0).first()
# 最后一个章节的下一章为该章节的id
lc.next_category_id = new_fc_id
# 构造章节加入,该章节为最后一章 / 第一章
new_fc = FirstCategory(name=title,
belong_class_id=class_id,
next_category_id=0)
else:
# 插入到指定章节后
# 找到指定章节
found_fc = FirstCategory.query.filter_by(belong_class_id=class_id,
name=before).first()
# 保存原来的下一个章节id
next = found_fc.next_category_id
found_fc.next_category_id = new_fc_id
# 构造新章节，该章节为id=next的章节的后面一章
new_fc = FirstCategory(name=title,
belong_class_id=class_id,
next_category_id=next)
# 插入数据
db.session.add(new_fc)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def login():
data = request.get_json()
account = data.get("account")
password = data.get("password")
# 用户身份，若是教师，则is_teacher为True
is_teacher = data.get("is_teacher")
user = User.query.filter_by(account=account).first()
# 用户不存在
if not user or user.is_teacher != is_teacher:
return responseError(Responses.NO_USER_FOUND)
# 密码错误
if not user.check_password(password):
return responseError(Responses.INCORRECT_PASSWORD)
# 生成token
token = generate_token(user_id=user.id)
session["token"] = token
session["user_id"] = user.id
# 获取用户头像路径
user_avatar = "default.jpg"
if user.avatar != "default":
user_avatar = user.avatar
avatar_path = '/py3env/West2/West2OlineWork/static/avatars/%s' % user_avatar
# 用户账号，姓名，当前时间
account = user.account
username = user.username
date = datetime.datetime.now()
# 保存登录时间
session["login_date"] = date
# 获得头像base64编码
with open(avatar_path, 'rb') as f:
stream = base64.b64encode(f.read())
avatar_base64_str = bytes.decode(stream)
#print(avatar_base64_str)
# 返回数据
response_info = {
"avadar": avatar_base64_str,
"name": username,
"userid": account,
"user_id": user.id,
"date": date.strftime("%Y-%m-%d %H:%M:%S"),
"classNum": len(user.user_classes),
"token": token
}
return responseBody(data=response_info)
def del_notice():
try:
data = request.get_json()
user_id = int(data.get("user_id"))
class_id = int(data.get("class_id"))
notice_id = int(data.get("notice_id"))
user = User.query.get(user_id)
notice = Notices.query.get(notice_id)
# 1.不是老师则无法删除
# 2.是老师，但删除的不是该班级下的公告则失败
if not user.is_teacher or notice.belong_class_id != class_id:
return responseError(Responses.AUTHORIZATION_ERROR)
db.session.delete(notice)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def del_selected_stds():
try:
data = request.get_json()
class_id = int(data.get("class_id"))
# 要删除的学生id列表
selected_stds = data.get("selected_stds")
user_id = int(data.get("user_id"))
user_class = Class.query.get(class_id)
# 判断要操作的用户是不是老师
if not User.query.filter_by(id=user_id).first().is_teacher:
return responseError(Responses.AUTHORIZATION_ERROR)
for std in selected_stds:
student = User.query.get(int(std))
# 解除该学生和班级的关联
user_class.stds.remove(student)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def update_password():
try:
user_data = request.get_json()
user_id = int(user_data.get("user_id"))
old_password = user_data.get("old_password")
new_password1 = user_data.get("new_password1")
new_password2 = user_data.get("new_password2")
users = User.query.filter_by(id=user_id).first()
# 密码不等
if not users.check_password(old_password):
return responseError(Responses.INCORRECT_PASSWORD)
# 两次密码不一致
elif new_password1 != new_password2:
return responseError(Responses.NOT_SAME_PASSWORD)
else:
users.set_password(new_password1)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def del_talking():
try:
data = request.get_json()
talking_id = int(data.get("talking_id"))
t = Talkings.query.get(talking_id)
db.session.delete(t)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def post_notices():
try:
data = request.get_json()
title = data.get("title")
content = data.get("content")
class_id = int(data.get("class_id"))
user_id = int(data.get("user_id"))
Tech = User.query.filter_by(id=user_id).first()
if not Tech.is_teacher:
return responseError(Responses.AUTHORIZATION_ERROR)
else:
notice = Notices(title=title,
content=content,
belong_class_id=class_id)
db.session.add(notice)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def del_work():
try:
data = request.get_json()
assignment_id = int(data.get("assignment_id"))
assign = Assignment.query.get(assignment_id)
os.remove(assign.content)
db.session.delete(assign)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def rename_work():
try:
data = request.get_json()
name = data.get("name")
assignment_id = int(data.get("assignment_id"))
assign = Assignment.query.get(assignment_id)
assign.name = name
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def get_submit():
try:
data = request.get_json()
# 提交用户
user_id = int(data.get("user_id"))
# 作业id
assignment_id = int(data.get("assignment_id"))
fs = FinishStatus.query.filter_by(assignment_id=assignment_id,
finish_user_id=user_id).first()
if fs is None:
return responseError(Responses.NO_RECORD_FOUND)
response_info = [{
"content":
fs.finish_content,
# 上次修改时间
"update_time":
datetime.datetime.strftime(fs.finish_time, "%Y-%m-%d %H:%M:%S")
}]
return responseBody(data=response_info)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def class_num_management():
try:
data = request.get_json()
class_id = int(data.get("class_id"))
user_id = int(data.get("user_id"))
# 判断要操作的用户是不是老师
if not User.query.filter_by(id=user_id).first().is_teacher:
return responseError(Responses.AUTHORIZATION_ERROR)
teacher_class = Class.query.get(class_id)
stds = User.query.with_parent(teacher_class).filter_by(
is_teacher=False).all()
Message = []
for s in stds:
Message.append({
'user_id': s.id,
'account': s.account,
'username': s.username
})
return responseBody(data=Message)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def apply_class():
try:
data = request.get_json()
user_id = int(data.get("user_id"))
class_name = data.get("class_name")
user = User.query.filter_by(id=user_id).first()
if not user.is_teacher:
return responseError(Responses.AUTHORIZATION_ERROR)
# 若为空，则默认值
class_info = data.get("class_info")
if class_info.strip() == "":
c = Class(class_name=class_name)
else:
c = Class(class_name=class_name, info=class_info)
c.stds.append(user)
db.session.add(c)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def delete_comments():
try:
data = request.get_json()
user_id = int(data.get("user_id"))
comment_id = int(data.get("comment_id"))
comments = Comments.query.filter_by(from_user_id=user_id,
id=comment_id).first()
db.session.delete(comments)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def rename_fc():
try:
data = request.get_json()
name = data.get("name")
fc_id = data.get("fc_id")
fc_id = int(fc_id.split("-")[1])
fc = FirstCategory.query.get(fc_id)
fc.name = name
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def class_management():
try:
data = request.get_json()
user_id = int(data.get("user_id"))
user = User.query.filter_by(id=user_id).first()
if not user.is_teacher:
return responseError(Responses.AUTHORIZATION_ERROR)
classes = User.query.get(user_id).user_classes
Message = [{
'avatar': user.avatar,
}]
classes_message = []
for c in classes:
classes_message.append({
'subName': c.class_name,
'class_id': c.id,
'num': len(c.stds)
})
Message[0]["classes_message"] = classes_message
return responseBody(data=Message)
except Exception as e:
print(e)
return responseError(Responses.PARAMETERS_ERROR)
def rename_sc():
try:
data = request.get_json()
# sc_id 是 2-XX 的形式
# 获得要删除的章节的id
sc_id = data.get("sc_id")
sc_id = int(sc_id.split("-")[1])
name = data.get("name")
sc = SecondCategory.query.get(sc_id)
sc.name = name
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseError(Responses.PARAMETERS_ERROR)
def close_class():
try:
data = request.get_json()
user_id = int(data.get("user_id"))
class_id = int(data.get("class_id"))
user = User.query.filter_by(id=user_id).first()
if not user.is_teacher:
return responseError(Responses.AUTHORIZATION_ERROR)
found_class = Class.query.get(class_id)
db.session.delete(found_class)
db.session.commit()
return responseSuccess(Responses.OPERATION_SUCCESS)
except Exception as e:
print(e)
db.session.rollback()
return responseSuccess(Responses.PARAMETERS_ERROR)
