- 开发语言：Python
- 框架：django
- Python版本：python3.8
- 数据库：mysql 5.7
- 数据库工具：Navicat12
- 开发软件：PyCharm
系统展示
系统首页
用户注册
评价数据
个人中心
管理员登录
管理员功能界面
用户管理
评价数据
评价预测
交流论坛
举报记录
看板展示
摘要
本文介绍了一个基于Django框架构建的课程教学评价系统，该系统旨在通过创新的在线管理手段，突破传统管理模式的局限，向用户提供更为个性化和便捷的服务。这个综合性的课程教学评价系统集成了用户、评价数据、评价预测、论坛分类、交流论坛等多项管理功能。它充分利用了Django框架的轻便性、高效运行能力和易于扩展的特点，结合现代Web技术，打造了一个功能全面且易于操作的管理平台。
通过深入分析课程教学评价系统的业务需求及用户特征，本文详细探讨了该系统的设计初衷、实现路径以及核心功能模块。在信息泛滥的今天，传统的企业管理方式已难以适应用户对个性化和便捷化服务的期望。这个基于Django的课程教学评价系统应运而生，旨在通过线上化管理，实现招聘信息的高效整合与个性化管理，从而提升用户满意度和平台的综合竞争力。
该系统通过构建用户、评价数据、评价预测、论坛分类、交流论坛等核心功能，实现了资源的有效整合与个性化服务。这一创新不仅提升了课程教学评价系统的效率和服务质量，还显著增强了用户的个性化体验和互动性。
研究背景
传统的课程教学评价多依赖人工问卷、纸质测评等方式，存在数据采集效率低、分析维度单一、反馈滞后等问题，难以满足新时代教育管理和质量监控的需求。国家大力倡导教育数字化转型，《教育信息化2.0行动计划》《深化新时代教育评价改革总体方案》等政策文件明确提出要创新教育评价方式，利用大数据、人工智能等技术构建智能化、多元化的教学评价体系。课程教学评价系统课题应运而生。该课题旨在整合先进的信息技术，通过构建涵盖学生评教、同行互评、教师自评、教学督导评价等多主体参与的评价体系，实现评价数据的实时采集、智能分析与动态反馈，为教学质量提升、教师专业发展和教育决策提供科学依据。在高校"双一流"建设和职业教育高质量发展的进程中，对精准教学评价的需求愈发迫切，开发一套功能完备、操作便捷、适应性强的课程教学评价系统，不仅有助于解决当前教育评价实践中的痛点问题，还能推动教育评价改革向纵深发展，具有重要的理论价值和实践意义。
关键技术
Python是解释型的脚本语言，在运行过程中，把程序转换为字节码和机器语言，说明性语言的程序在运行之前不必进行编译，而是一个专用的解释器，当被执行时，它都会被翻译，与之对应的还有编译性语言。
同时，这也是一种用于电脑编程的跨平台语言，这是一门将编译、交互和面向对象相结合的脚本语言（script language）。
Django用Python编写，属于开源Web应用程序框架。采用（模型M、视图V和模板t）的框架模式。该框架以比利时吉普赛爵士吉他手詹戈·莱因哈特命名。该架构的主要组件如下：
1.用于创建模型的对象关系映射。
2.最终目标是为用户设计一个完美的管理界面。
3.是目前最流行的URL设计解决方案。
4.模板语言对设计师来说是最友好的。
5.缓存系统。
Vue是一款流行的开源JavaScript框架，用于构建用户界面和单页面应用程序。Vue的核心库只关注视图层，易于上手并且可以与其他库或现有项目轻松整合。
MYSQL数据库运行速度快，安全性能也很高，而且对使用的平台没有任何的限制，所以被广泛应运到系统的开发中。MySQL是一个开源和多线程的关系管理数据库系统，MySQL是开放源代码的数据库，具有跨平台性。
B/S（浏览器/服务器）结构是目前主流的网络化的结构模式，它能够把系统核心功能集中在服务器上面，可以帮助系统开发人员简化操作，便于维护和使用。
系统分析
对系统的可行性分析以及对所有功能需求进行详细的分析，来查看该系统是否具有开发的可能。
系统设计
功能模块设计和数据库设计这两部分内容都有专门的表格和图片表示。
系统实现
当访客浏览器中输入系统网址并访问时，首先映入眼帘的是系统的首页界面。在这个页面上，访客可以清晰地看到课程教学评价系统的导航栏，其中包含了诸如首页、评价数据、交流论坛、公告资讯、个人中心等多个功能模块的链接。在个人中心页面可以输入个人详细信息，进行信息更新操作，还可以对修改密码、我的发布、我的收藏等进行详细操作。管理员成功登录系统后，将能够访问并操作多个功能模块，包括但不限于系统首页、用户、评价数据、评价预测、论坛分类、交流论坛、举报记录、系统管理、个人中心等，每一项功能模块都提供了详尽的操作选项。
代码实现
python
from sqlalchemy import create_engine
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder, StandardScaler, MinMaxScaler
from keras.models import Sequential
from keras.layers import LSTM, Dense, Dropout
pd.options.mode.chained_assignment = None # default='warn'
#获取当前文件路径的根目录
parent_directory = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
dbtype, host, port, user, passwd, dbName, charset,hasHadoop = config_read(os.path.join(parent_directory,"config.ini"))
#MySQL连接配置
mysql_config = {
'host': host,
'user':user,
'password': passwd,
'database': dbName,
'port':port
}
def auto_figsize(x_data, base_width=8, base_height=6, width_per_point=0.2):
"""根据数据点数量自动调整画布宽度"""
num_points = len(x_data)
dynamic_width = base_width + width_per_point * num_points
return (dynamic_width, base_height)
#获取预测可视化图表接口
def evaluationdataforecast_forecastimgs(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, 'message': 'success'}
# 指定目录
directory = os.path.join(parent_directory, "templates", "upload", "evaluationdataforecast")
# 获取目录下的所有文件和文件夹名称
all_items = os.listdir(directory)
# 过滤出文件（排除文件夹）
files = [f'upload/evaluationdataforecast/{item}' for item in all_items if os.path.isfile(os.path.join(directory, item))]
msg["data"] = files
fontlist=[]
for font in fm.fontManager.ttflist:
fontlist.append(font.name)
msg["message"]=fontlist
return JsonResponse(msg, encoder=CustomJsonEncoder)
# 定义函数创建时间序列数据集
def create_dataset(data, time_step=1):
X, Y = [], []
for i in range(len(data) - time_step - 1):
a = data[i:(i + time_step), :]
X.append(a)
Y.append(data[i + time_step, :])
return np.array(X), np.array(Y)
def evaluationdataforecast_forecast(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
#1.获取数据集
connection = pymysql.connect(**mysql_config)
query = "SELECT evaluationdate, sname,coursename,overallsatisfaction,teacherevaluation FROM evaluationdata ORDER BY evaluationdate ASC"
#2.处理缺失值
data = pd.read_sql(query, connection).dropna()
# 转换日期格式为datetime
date_format = data['evaluationdate'].iloc[0]
if isinstance(date_format, (datetime.date, datetime.datetime)):
date_format=''
elif "年" in date_format and "月" in date_format and "日" in date_format:
date_format='%Y年%m月%d日'
elif "年" in date_format and "月" in date_format:
date_format='%Y年%m月'
elif "年" in date_format:
date_format='%Y年'
else:
date_format=''
if date_format=="" or date_format==None:
data['evaluationdate'] = pd.to_datetime(data['evaluationdate'])
else:
data['evaluationdate'] = pd.to_datetime(data['evaluationdate'], format=date_format)
data.set_index('evaluationdate', inplace=True)
coursename_encoder = LabelEncoder()
data['coursename'] = coursename_encoder.fit_transform(data['coursename'])
sname_encoder = LabelEncoder()
data['sname'] = sname_encoder.fit_transform(data['sname'])
#只选择需要的列
data = data[[
'sname',
'coursename',
'overallsatisfaction',
'teacherevaluation',
]]
# 归一化处理（为了LSTM的训练）
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(data)
#设置时间步长
time_step = int(len(data)/10)# 使用过去30的数据
if time_step>30:
time_step=30
if time_step<=0:
time_step=1
X, y = create_dataset(scaled_data, time_step)
#划分训练集和测试集
train_size = int(len(X) * 0.8) # 80%的数据用于训练
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]
# 查看训练数据集的形状
print(f'X_train shape: {X_train.shape}, y_train shape: {y_train.shape}')
# 创建 LSTM 模型
model = Sequential()
model.add(LSTM(50, return_sequences=True, input_shape=(X_train.shape[1], X_train.shape[2])))
model.add(Dropout(0.2)) # 防止过拟合
model.add(LSTM(50, return_sequences=False))
model.add(Dropout(0.2))
model.add(Dense(len(data.columns), activation='relu')) # 输出层，预测
#编译模型
model.compile(optimizer='adam', loss='mean_squared_error')
#训练模型
model.fit(X_train, y_train, epochs=100, batch_size=32, verbose=1)
#进行预测
train_predict = model.predict(X_train)
test_predict = model.predict(X_test)
#将预测结果反归一化
train_predict = scaler.inverse_transform(train_predict)
test_predict = scaler.inverse_transform(test_predict)
#绘制预测结果
plt.rcParams['font.sans-serif'] = ['SimHei'] # 使用黑体 SimHei
plt.rcParams['axes.unicode_minus'] = False # 解决负号 '-' 显示为方块的问题
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 1 -1], label='训练sname预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 1 -1],
label='测试sname预测', color='red')
plt.plot(data.index, data['sname'], label='实际sname', color='green')
plt.title('sname预测')
plt.xlabel('Date')
plt.ylabel('sname')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","evaluationdataforecast","sname_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 2 -1], label='训练coursename预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 2 -1],
label='测试coursename预测', color='red')
plt.plot(data.index, data['coursename'], label='实际coursename', color='green')
plt.title('coursename预测')
plt.xlabel('Date')
plt.ylabel('coursename')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","evaluationdataforecast","coursename_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 3 -1], label='训练overallsatisfaction预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 3 -1],
label='测试overallsatisfaction预测', color='red')
plt.plot(data.index, data['overallsatisfaction'], label='实际overallsatisfaction', color='green')
plt.title('overallsatisfaction预测')
plt.xlabel('Date')
plt.ylabel('overallsatisfaction')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","evaluationdataforecast","overallsatisfaction_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 4 -1], label='训练teacherevaluation预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 4 -1],
label='测试teacherevaluation预测', color='red')
plt.plot(data.index, data['teacherevaluation'], label='实际teacherevaluation', color='green')
plt.title('teacherevaluation预测')
plt.xlabel('Date')
plt.ylabel('teacherevaluation')
plt.legend()
directory =os.path.join(parent_directory,"templates","upload","evaluationdataforecast","teacherevaluation_prediction.png")
os.makedirs(os.path.dirname(directory), exist_ok=True)
plt.savefig(directory)
plt.clf()
plt.close()
#准备未来2的输入数据
last_data_days = scaled_data[-time_step:] #取最后time_step的数据
future_predictions = []
for _ in range(2): # 预测未来2
last_data_days = last_data_days.reshape((1, time_step, len(data.columns))) # 重塑数据
prediction = model.predict(last_data_days)
future_predictions.append(prediction[0])
last_data_days = np.append(last_data_days[:, 1:, :], [prediction], axis=1) # 更新输入数据
#转换为原始数据
future_predictions = scaler.inverse_transform(future_predictions)
#获取当前日期
last_date = data.index[-1] # 数据集中最后一个日期
future_dates = [last_date + datetime.timedelta(days=i) for i in range(1, 2+1)] # 生成未来2日的日期
df = pd.DataFrame(columns=[
'evaluationdate',
'sname',
'coursename',
'overallsatisfaction',
'teacherevaluation',
])
df['evaluationdate'] = future_dates
df['sname'] = future_predictions[:, 1 -1]
df['coursename'] = future_predictions[:, 2 -1]
df['overallsatisfaction'] = future_predictions[:, 3 -1]
df['teacherevaluation'] = future_predictions[:, 4 -1]
df['coursename']=df['coursename'].astype(int)
df['coursename'] = coursename_encoder.inverse_transform(df['coursename'])
df['overallsatisfaction']=df['overallsatisfaction'].astype(int)
df['teacherevaluation']=df['teacherevaluation'].astype(int)
df['sname']=df['sname'].astype(int)
df['sname'] = sname_encoder.inverse_transform(df['sname'])
#9.创建数据库连接,将DataFrame 插入数据库
connection_string = f"mysql+pymysql://{mysql_config['user']}:{mysql_config['password']}@{mysql_config['host']}:{mysql_config['port']}/{mysql_config['database']}"
engine = create_engine(connection_string)
try:
df.to_sql('evaluationdataforecast', con=engine, if_exists='append', index=False)
print("数据更新成功！")
except Exception as e:
print(f"发生错误: {e}")
finally:
engine.dispose() # 关闭数据库连接
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_register(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
req_dict['mima'] = Common.md5(Common, req_dict.get('mima'))
error = evaluationdataforecast.createbyreq(evaluationdataforecast, evaluationdataforecast, req_dict)
if error is Exception or (type(error) is str and "Exception" in error):
msg['code'] = crud_error_code
msg['msg'] = "用户已存在,请勿重复注册!"
else:
msg['data'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_login(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
req_dict['password'] = Common.md5(Common, req_dict.get('password'))
datas = evaluationdataforecast.getbyparams(evaluationdataforecast, evaluationdataforecast, req_dict)
if not datas:
msg['code'] = password_error_code
msg['msg'] = mes.password_error_code
return JsonResponse(msg, encoder=CustomJsonEncoder)
try:
__sfsh__= evaluationdataforecast.__sfsh__
except:
__sfsh__=None
if __sfsh__=='是':
if datas[0].get('sfsh')!='是':
msg['code']=other_code
msg['msg'] = "账号已锁定，请联系管理员审核!"
return JsonResponse(msg, encoder=CustomJsonEncoder)
req_dict['id'] = datas[0].get('id')
return Auth.authenticate(Auth, evaluationdataforecast, req_dict)
def evaluationdataforecast_logout(request):
if request.method in ["POST", "GET"]:
msg = {
"msg": "登出成功",
"code": 0
}
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_resetPass(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
columns= evaluationdataforecast.getallcolumn( evaluationdataforecast, evaluationdataforecast)
try:
__loginUserColumn__= evaluationdataforecast.__loginUserColumn__
except:
__loginUserColumn__=None
username=req_dict.get(list(req_dict.keys())[0])
if __loginUserColumn__:
username_str=__loginUserColumn__
else:
username_str=username
if 'mima' in columns:
password_str='mima'
else:
password_str='password'
init_pwd = '123456'
init_pwd = Common.md5(Common, init_pwd)
recordsParam = {}
recordsParam[username_str] = req_dict.get("username")
records=evaluationdataforecast.getbyparams(evaluationdataforecast, evaluationdataforecast, recordsParam)
if len(records)<1:
msg['code'] = 400
msg['msg'] = '用户不存在'
return JsonResponse(msg, encoder=CustomJsonEncoder)
eval('''evaluationdataforecast.objects.filter({}='{}').update({}='{}')'''.format(username_str,username,password_str,init_pwd))
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_session(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code,"msg": mes.normal_code, "data": {}}
req_dict={"id":request.session.get('params').get("id")}
msg['data'] = evaluationdataforecast.getbyparams(evaluationdataforecast, evaluationdataforecast, req_dict)[0]
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_default(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code,"msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
req_dict.update({"isdefault":"是"})
data=evaluationdataforecast.getbyparams(evaluationdataforecast, evaluationdataforecast, req_dict)
if len(data)>0:
msg['data'] = data[0]
else:
msg['data'] = {}
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_page(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":{"currPage":1,"totalPage":1,"total":1,"pageSize":10,"list":[]}}
req_dict = request.session.get("req_dict")
global evaluationdataforecast
#当前登录用户信息
tablename = request.session.get("tablename")
msg['data']['list'], msg['data']['currPage'], msg['data']['totalPage'], msg['data']['total'], \
msg['data']['pageSize'] =evaluationdataforecast.page(evaluationdataforecast, evaluationdataforecast, req_dict, request)
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_autoSort(request):
'''
．智能推荐功能(表属性：[intelRecom（是/否）],新增clicktime[前端不显示该字段]字段（调用info/detail接口的时候更新），按clicktime排序查询)
主要信息列表（如商品列表，新闻列表）中使用，显示最近点击的或最新添加的5条记录就行
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":{"currPage":1,"totalPage":1,"total":1,"pageSize":10,"list":[]}}
req_dict = request.session.get("req_dict")
if "clicknum" in evaluationdataforecast.getallcolumn(evaluationdataforecast,evaluationdataforecast):
req_dict['sort']='clicknum'
elif "browseduration" in evaluationdataforecast.getallcolumn(evaluationdataforecast,evaluationdataforecast):
req_dict['sort']='browseduration'
else:
req_dict['sort']='clicktime'
req_dict['order']='desc'
msg['data']['list'], msg['data']['currPage'], msg['data']['totalPage'], msg['data']['total'], \
msg['data']['pageSize'] = evaluationdataforecast.page(evaluationdataforecast,evaluationdataforecast, req_dict)
return JsonResponse(msg, encoder=CustomJsonEncoder)
#分类列表
def evaluationdataforecast_lists(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":[]}
msg['data'],_,_,_,_ = evaluationdataforecast.page(evaluationdataforecast, evaluationdataforecast, {})
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_query(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
try:
query_result = evaluationdataforecast.objects.filter(**request.session.get("req_dict")).values()
msg['data'] = query_result[0]
except Exception as e:
msg['code'] = crud_error_code
msg['msg'] = f"发生错误：{e}"
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_list(request):
'''
前台分页
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":{"currPage":1,"totalPage":1,"total":1,"pageSize":10,"list":[]}}
req_dict = request.session.get("req_dict")
#获取全部列名
columns= evaluationdataforecast.getallcolumn( evaluationdataforecast, evaluationdataforecast)
if "vipread" in req_dict and "vipread" not in columns:
del req_dict["vipread"]
#表属性[foreEndList]前台list:和后台默认的list列表页相似,只是摆在前台,否:指没有此页,是:表示有此页(不需要登陆即可查看),前要登:表示有此页且需要登陆后才能查看
try:
__foreEndList__=evaluationdataforecast.__foreEndList__
except:
__foreEndList__=None
try:
__foreEndListAuth__=evaluationdataforecast.__foreEndListAuth__
except:
__foreEndListAuth__=None
#authSeparate
try:
__authSeparate__=evaluationdataforecast.__authSeparate__
except:
__authSeparate__=None
if __foreEndListAuth__ =="是" and __authSeparate__=="是":
tablename=request.session.get("tablename")
if tablename!="users" and request.session.get("params") is not None:
req_dict['userid']=request.session.get("params").get("id")
tablename = request.session.get("tablename")
if tablename == "users" and req_dict.get("userid") != None:#判断是否存在userid列名
del req_dict["userid"]
else:
__isAdmin__ = None
allModels = apps.get_app_config('main').get_models()
for m in allModels:
if m.__tablename__==tablename:
try:
__isAdmin__ = m.__isAdmin__
except:
__isAdmin__ = None
break
if __isAdmin__ == "是":
if req_dict.get("userid"):
# del req_dict["userid"]
pass
else:
#非管理员权限的表,判断当前表字段名是否有userid
if "userid" in columns:
try:
pass
except:
pass
#当列属性authTable有值(某个用户表)[该列的列名必须和该用户表的登陆字段名一致]，则对应的表有个隐藏属性authTable为"是"，那么该用户查看该表信息时，只能查看自己的
try:
__authTables__=evaluationdataforecast.__authTables__
except:
__authTables__=None
if __authTables__!=None and __authTables__!={} and __foreEndListAuth__=="是":
for authColumn,authTable in __authTables__.items():
if authTable==tablename:
try:
del req_dict['userid']
except:
pass
params = request.session.get("params")
req_dict[authColumn]=params.get(authColumn)
username=params.get(authColumn)
break
if evaluationdataforecast.__tablename__[:7]=="discuss":
try:
del req_dict['userid']
except:
pass
q = Q()
msg['data']['list'], msg['data']['currPage'], msg['data']['totalPage'], msg['data']['total'], \
msg['data']['pageSize'] = evaluationdataforecast.page(evaluationdataforecast, evaluationdataforecast, req_dict, request, q)
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_save(request):
'''
后台新增
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
if 'clicktime' in req_dict.keys():
del req_dict['clicktime']
tablename=request.session.get("tablename")
__isAdmin__ = None
allModels = apps.get_app_config('main').get_models()
for m in allModels:
if m.__tablename__==tablename:
try:
__isAdmin__ = m.__isAdmin__
except:
__isAdmin__ = None
break
#获取全部列名
columns= evaluationdataforecast.getallcolumn( evaluationdataforecast, evaluationdataforecast)
if tablename!='users' and req_dict.get("userid")==None and 'userid' in columns and __isAdmin__!='是':
params=request.session.get("params")
req_dict['userid']=params.get('id')
if 'addtime' in req_dict.keys():
del req_dict['addtime']
idOrErr= evaluationdataforecast.createbyreq(evaluationdataforecast,evaluationdataforecast, req_dict)
if idOrErr is Exception:
msg['code'] = crud_error_code
msg['msg'] = idOrErr
else:
msg['data'] = idOrErr
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_add(request):
'''
前台新增
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
tablename=request.session.get("tablename")
#获取全部列名
columns= evaluationdataforecast.getallcolumn( evaluationdataforecast, evaluationdataforecast)
try:
__authSeparate__=evaluationdataforecast.__authSeparate__
except:
__authSeparate__=None
if __authSeparate__=="是":
tablename=request.session.get("tablename")
if tablename!="users" and 'userid' in columns:
try:
req_dict['userid']=request.session.get("params").get("id")
except:
pass
try:
__foreEndListAuth__=evaluationdataforecast.__foreEndListAuth__
except:
__foreEndListAuth__=None
if __foreEndListAuth__ and __foreEndListAuth__!="否":
tablename=request.session.get("tablename")
if tablename!="users":
req_dict['userid']=request.session.get("params").get("id")
if 'addtime' in req_dict.keys():
del req_dict['addtime']
error= evaluationdataforecast.createbyreq(evaluationdataforecast,evaluationdataforecast, req_dict)
if error is Exception:
msg['code'] = crud_error_code
msg['msg'] = error
else:
msg['data'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_thumbsup(request,id_):
'''
点赞：表属性thumbsUp[是/否]，刷表新增thumbsupnum赞和crazilynum踩字段，
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
id_=int(id_)
type_=int(req_dict.get("type",0))
rets=evaluationdataforecast.getbyid(evaluationdataforecast,evaluationdataforecast,id_)
update_dict={
"id":id_,
}
if type_==1:#赞
update_dict["thumbsupnum"]=int(rets[0].get('thumbsupnum'))+1
elif type_==2:#踩
update_dict["crazilynum"]=int(rets[0].get('crazilynum'))+1
error = evaluationdataforecast.updatebyparams(evaluationdataforecast,evaluationdataforecast, update_dict)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_info(request,id_):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
data = evaluationdataforecast.getbyid(evaluationdataforecast,evaluationdataforecast, int(id_))
if len(data)>0:
msg['data']=data[0]
if msg['data'].__contains__("reversetime"):
if isinstance(msg['data']['reversetime'], datetime.datetime):
msg['data']['reversetime'] = msg['data']['reversetime'].strftime("%Y-%m-%d %H:%M:%S")
else:
if msg['data']['reversetime'] != None:
reversetime = datetime.datetime.strptime(msg['data']['reversetime'], '%Y-%m-%d %H:%M:%S')
msg['data']['reversetime'] = reversetime.strftime("%Y-%m-%d %H:%M:%S")
#浏览点击次数
try:
__browseClick__= evaluationdataforecast.__browseClick__
except:
__browseClick__=None
if __browseClick__=="是" and "clicknum" in evaluationdataforecast.getallcolumn(evaluationdataforecast,evaluationdataforecast):
try:
clicknum=int(data[0].get("clicknum",0))+1
except:
clicknum=0+1
click_dict={"id":int(id_),"clicknum":clicknum,"clicktime":datetime.datetime.now()}
ret=evaluationdataforecast.updatebyparams(evaluationdataforecast,evaluationdataforecast,click_dict)
if ret!=None:
msg['code'] = crud_error_code
msg['msg'] = ret
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_detail(request,id_):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
data =evaluationdataforecast.getbyid(evaluationdataforecast,evaluationdataforecast, int(id_))
if len(data)>0:
msg['data']=data[0]
if msg['data'].__contains__("reversetime"):
if isinstance(msg['data']['reversetime'], datetime.datetime):
msg['data']['reversetime'] = msg['data']['reversetime'].strftime("%Y-%m-%d %H:%M:%S")
else:
if msg['data']['reversetime'] != None:
reversetime = datetime.datetime.strptime(msg['data']['reversetime'], '%Y-%m-%d %H:%M:%S')
msg['data']['reversetime'] = reversetime.strftime("%Y-%m-%d %H:%M:%S")
#浏览点击次数
try:
__browseClick__= evaluationdataforecast.__browseClick__
except:
__browseClick__=None
if __browseClick__=="是" and "clicknum" in evaluationdataforecast.getallcolumn(evaluationdataforecast,evaluationdataforecast):
try:
clicknum=int(data[0].get("clicknum",0))+1
except:
clicknum=0+1
click_dict={"id":int(id_),"clicknum":clicknum,"clicktime":datetime.datetime.now()}
ret=evaluationdataforecast.updatebyparams(evaluationdataforecast,evaluationdataforecast,click_dict)
if ret!=None:
msg['code'] = crud_error_code
msg['msg'] = ret
return JsonResponse(msg, encoder=CustomJsonEncoder)
def evaluationdataforecast_update(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
if 'clicktime' in req_dict.keys() and req_dict['clicktime']=="None":
del req_dict['clicktime']
if req_dict.get("mima") and "mima" not in evaluationdataforecast.getallcolumn(evaluationdataforecast,evaluationdataforecast) :
del req_dict["mima"]
if req_dict.get("password") and "password" not in evaluationdataforecast.getallcolumn(evaluationdataforecast,evaluationdataforecast) :
del req_dict["password"]
try:
del req_dict["clicknum"]
except:
pass
error = evaluationdataforecast.updatebyparams(evaluationdataforecast, evaluationdataforecast, req_dict)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def evaluationdataforecast_delete(request):
'''
批量删除
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
req_dict = request.session.get("req_dict")
error=evaluationdataforecast.deletes(evaluationdataforecast,
evaluationdataforecast,
req_dict.get("ids")
)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def evaluationdataforecast_vote(request,id_):
'''
浏览点击次数（表属性[browseClick:是/否]，点击字段（clicknum），调用info/detail接口的时候后端自动+1）、投票功能（表属性[vote:是/否]，投票字段（votenum）,调用vote接口后端votenum+1）
统计商品或新闻的点击次数；提供新闻的投票功能
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code}
data= evaluationdataforecast.getbyid(evaluationdataforecast, evaluationdataforecast, int(id_))
for i in data:
votenum=i.get('votenum')
if votenum!=None:
params={"id":int(id_),"votenum":votenum+1}
error=evaluationdataforecast.updatebyparams(evaluationdataforecast,evaluationdataforecast,params)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def evaluationdataforecast_importExcel(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": "成功", "data": {}}
excel_file = request.FILES.get("file", "")
if excel_file.size > 100 * 1024 * 1024: # 限制为 100MB
msg['code'] = 400
msg["msg"] = '文件大小不能超过100MB'
return JsonResponse(msg)
file_type = excel_file.name.split('.')[1]
if file_type in ['xlsx', 'xls']:
data = xlrd.open_workbook(filename=None, file_contents=excel_file.read())
table = data.sheets()[0]
rows = table.nrows
try:
for row in range(1, rows):
row_values = table.row_values(row)
req_dict = {}
evaluationdataforecast.createbyreq(evaluationdataforecast, evaluationdataforecast, req_dict)
except:
pass
else:
msg = {
"msg": "文件类型错误",
"code": 500
}
return JsonResponse(msg)
def evaluationdataforecast_autoSort2(request):
return JsonResponse({"code": 0, "msg": '', "data":{}})系统测试
为了确保课程教学评价系统的全面功能性和稳定性，制定了一套详尽的测试计划。该计划涵盖了后台用户、评价数据、评价预测、论坛分类、交流论坛、举报记录等核心管理模块，旨在通过全面的测试用例，确保平台的各个组成部分都能经过充分的检验。在测试过程中，将重点关注系统的响应速度、数据处理准确性以及用户界面的友好性，确保用户在实际操作中能够享受到流畅、高效的服务体验。同时，还将模拟各种可能的异常情况，以检验系统在极端条件下的稳定性和恢复能力。通过这套全面的测试计划，有信心发现并修复潜在的问题，确保课程教学评价系统在上线后能够稳定运行，为用户提供可靠、高效的管理解决方案。
结论
本文聚焦于课程教学评价系统的设计与实现，借助Django和Python等前沿的技术，打造了一个功能全面且用户界面友好的管理系统。文章开篇即介绍了该平台的背景信息及其研究的重要性，随后深入剖析了平台的需求分析、系统设计与实现细节，并完成了全面的功能测试。
在后端开发层面，采用了Django框架来构建稳定且高效的服务端，这一选择极大地简化了配置和开发流程。同时，MyBatis Plus与MySQL的强强联合，确保了数据持久化操作的高效执行。而在前端开发方面，Python框架的组件化开发模式和双向数据绑定机制，使得能够迅速构建出响应迅速且动态变化的用户界面。在系统功能实现上，Django与Python的完美结合，让成功实现了用户、评价数据、评价预测、论坛分类、交流论坛、举报记录、系统管理等核心功能，为管理员提供了便捷的数据管理平台。为用户带来了流畅的使用体验。尽管课程教学评价系统的设计与实现已取得初步成果，但仍存在诸多待改进和完善之处。例如，可以在现有功能的基础上，进一步拓展系统功能，以全面提升用户的整体体验，让用户能够更加轻松愉悦地使用该平台。