博主介绍：
✌我是阿龙，一名专注于Java技术领域的程序员，全网拥有10W+粉丝。作为CSDN特邀作者、博客专家、新星计划导师，我在计算机毕业设计开发方面积累了丰富的经验。同时，我也是掘金、华为云、阿里云、InfoQ等平台的优质作者。通过长期分享和实战指导，我致力于帮助更多学生完成毕业项目和技术提升。技术范围：
我熟悉的技术领域涵盖SpringBoot、Vue、SSM、HLMT、Jsp、PHP、Nodejs、Python、爬虫、数据可视化、小程序、安卓app、大数据、物联网、机器学习等方面的设计与开发。如果你有任何技术难题，我都乐意与你分享解决方案。主要内容：
我的服务内容包括：免费功能设计、开题报告、任务书、中期检查PPT、系统功能实现、代码编写、论文撰写与辅导、论文降重、长期答辩答疑辅导。我还提供腾讯会议一对一的专业讲解和模拟答辩演练，帮助你全面掌握答辩技巧与代码逻辑。🍅获取源码请在文末联系我🍅
温馨提示：文末有 CSDN 平台官方提供的阿龙联系方式的名片！
温馨提示：文末有 CSDN 平台官方提供的阿龙联系方式的名片！
温馨提示：文末有 CSDN 平台官方提供的阿龙联系方式的名片！
感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人
目录
感兴趣的可以先收藏起来，还有大家在毕设选题，项目以及论文编写等相关问题都可以给我留言咨询，希望帮助更多的人
源码获取文章下方名片联系我即可~大家点赞、收藏、关注、评论啦 、查看👇🏻获取联系方式👇🏻精彩专栏推荐订阅：在下方专栏
一、详细操作演示视频
在文章的尾声，您会发现一张电子名片👤，欢迎通过名片上的联系方式与我取得联系，以获取更多关于项目演示的详尽视频内容。视频将帮助您全面理解项目的关键点和操作流程。期待与您的进一步交流！
2.1 mysql技术介绍
MySQL是一种开源的关系型数据库管理系统，它广泛应用于大规模数据存储与管理。作为一个成熟的数据库系统，MySQL具有高效、可靠、易于管理和扩展的优点，尤其在处理大量数据时表现出色。对于心脏病数据分析与可视化项目，MySQL被用于存储和管理患者的基本信息、病历数据、实验室检测结果、临床诊断记录等。通过使用MySQL，研究人员可以高效地查询和处理大量数据，同时确保数据的一致性和完整性。
MySQL支持SQL语言，具有强大的数据操作功能，如数据插入、查询、更新和删除等。此外，MySQL还支持事务管理、数据备份、恢复及安全访问控制，这些功能确保了医疗数据的安全性和可靠性。在本研究中，MySQL用于构建心脏病数据存储系统，并为后续的数据分析和可视化提供了稳定的数据库支持。
2.2 Python语言介绍
Python是一种解释型的高级编程语言，以其简洁、可读性强的语法和丰富的库支持而广泛应用于数据科学、机器学习、人工智能等领域。在心脏病数据分析与可视化中，Python发挥了至关重要的作用，主要用于数据的采集、清洗、处理、分析及结果可视化。
Python生态系统中有众多强大的库，如NumPy、Pandas、Matplotlib、Seaborn等，它们帮助研究人员高效地处理和分析心脏病相关的多维数据。NumPy和Pandas提供了强大的数据结构和数据处理功能，支持对大规模数据的高效操作。Matplotlib和Seaborn则提供了多样化的可视化工具，帮助将分析结果通过图表呈现，便于医生和医疗人员理解与决策。
此外，Python还具有丰富的机器学习库（如scikit-learn、TensorFlow、Keras等），为心脏病的预测与风险评估提供了强大的算法支持。在本研究中，Python被广泛应用于数据预处理、特征提取、建模以及结果可视化等多个方面，是实现心脏病数据分析和可视化的核心技术。
2.3 Django框架简介
Django是一个基于Python的开源Web框架，遵循“不要重复自己”（DRY）和“模型-视图-控制器”（MVC）设计模式。Django框架提供了一个高效、便捷的Web开发环境，特别适合快速开发高性能的Web应用。在心脏病数据分析与可视化项目中，Django主要用于构建系统的Web后台，使得数据的展示、管理和交互更加便捷。
Django的强大之处在于它的内置功能，包括身份认证、数据库管理、会话管理等，能够极大地减少开发的复杂度。Django还提供了一个强大的对象关系映射（ORM）系统，可以将Python对象与数据库中的数据表进行映射，使得数据操作更加直观和安全。通过Django框架，系统能够将心脏病数据进行存储、查询、处理，并将分析结果通过Web界面展示给用户，提供一个交互式的数据分析平台。
2.4 B/S架构
B/S架构（浏览器/服务器架构）是一种常见的Web应用架构模式。在B/S架构中，前端界面运行在用户的浏览器中，而后端的业务逻辑和数据存储则由服务器端处理。与传统的C/S（客户端/服务器）架构相比，B/S架构不需要用户安装额外的客户端软件，用户只需通过浏览器访问应用即可。
在本研究的心脏病数据分析与可视化系统中，B/S架构用于构建Web应用，用户可以通过浏览器访问系统，进行数据查询、分析和可视化展示。B/S架构的优势在于它能够简化系统的维护和升级过程，前端和后端可以独立开发和更新，不会互相干扰。同时，B/S架构使得系统的部署更加灵活，支持跨平台使用，能够方便地为多用户提供服务。
2.5 Scrapy简介
Scrapy是一个用于爬取网站数据的开源框架，主要用于抓取和提取网页中的信息。在心脏病数据分析与可视化项目中，Scrapy被用于收集心脏病相关的公共数据，如医学研究论文、患者案例、心脏病的最新治疗方法等。这些数据可以用于扩充分析数据集，帮助研究人员更全面地理解心脏病的发病机制和治疗效果。
Scrapy框架的优势在于其高效、灵活、可扩展，支持并发请求和异步处理，能够大幅提高数据抓取的效率。此外，Scrapy还具备强大的数据清洗和存储功能，可以将抓取到的数据保存到数据库中，方便后续的处理和分析。在本研究中，Scrapy不仅用于数据采集，还能将数据整理成结构化格式，便于进一步分析和可视化。
系统实现！
预测核心代码：
'user':user,
'password': passwd,
'database': dbName,
'port':port
}
# 定义函数创建时间序列数据集
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 heartdiseasedataforecast_forecast(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
#1.获取数据集
connection = pymysql.connect(**mysql_config)
query = "SELECT admissiondate, systolicpressure,heartrate,cardiovasculardisease FROM heartdiseasedata ORDER BY admissiondate ASC"
#2.处理缺失值
data = pd.read_sql(query, connection).dropna()
# 转换日期格式为datetime
date_format = data['admissiondate'].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['admissiondate'] = pd.to_datetime(data['admissiondate'])
else:
data['admissiondate'] = pd.to_datetime(data['admissiondate'], format=date_format)
data.set_index('admissiondate', inplace=True)
cardiovasculardisease_encoder = LabelEncoder()
data['cardiovasculardisease'] = cardiovasculardisease_encoder.fit_transform(data['cardiovasculardisease'])
#只选择需要的列
data = data[[
'systolicpressure',
'heartrate',
'cardiovasculardisease',
]]
# 归一化处理（为了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='训练systolicpressure预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 1 -1],
label='测试systolicpressure预测', color='red')
plt.plot(data.index, data['systolicpressure'], label='实际systolicpressure', color='green')
plt.title('systolicpressure预测')
plt.xlabel('Date')
plt.ylabel('systolicpressure')
plt.legend()
plt.savefig('systolicpressure_prediction.png')
plt.clf()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 2 -1], label='训练heartrate预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 2 -1],
label='测试heartrate预测', color='red')
plt.plot(data.index, data['heartrate'], label='实际heartrate', color='green')
plt.title('heartrate预测')
plt.xlabel('Date')
plt.ylabel('heartrate')
plt.legend()
plt.savefig('heartrate_prediction.png')
plt.clf()
plt.figure(figsize=(12, 6),dpi=80)
plt.plot(data.index[:len(train_predict)], train_predict[:, 3 -1], label='训练cardiovasculardisease预测',
color='blue')
plt.plot(data.index[len(train_predict) + time_step + 1:], test_predict[:, 3 -1],
label='测试cardiovasculardisease预测', color='red')
plt.plot(data.index, data['cardiovasculardisease'], label='实际cardiovasculardisease', color='green')
plt.title('cardiovasculardisease预测')
plt.xlabel('Date')
plt.ylabel('cardiovasculardisease')
plt.legend()
plt.savefig('cardiovasculardisease_prediction.png')
plt.clf()
#准备未来7的输入数据
last_data_days = scaled_data[-time_step:] #取最后time_step的数据
future_predictions = []
for _ in range(7): # 预测未来7
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=366*i) for i in range(1, 7+1)] # 生成未来7年的日期
df = pd.DataFrame(columns=[
'admissiondate',
'systolicpressure',
'heartrate',
'cardiovasculardisease',
])
df['admissiondate'] = [str(date.year) for date in future_dates]
df['systolicpressure'] = future_predictions[:, 1 -1]
df['heartrate'] = future_predictions[:, 2 -1]
df['cardiovasculardisease'] = future_predictions[:, 3 -1]
df['systolicpressure']=df['systolicpressure'].astype(int)
df['heartrate']=df['heartrate'].astype(int)
df['cardiovasculardisease']=df['cardiovasculardisease'].astype(int)
df['cardiovasculardisease'] = cardiovasculardisease_encoder.inverse_transform(df['cardiovasculardisease'])
#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('heartdiseasedataforecast', con=engine, if_exists='append', index=False)
print("数据更新成功！")
except Exception as e:
print(f"发生错误: {e}")
finally:
engine.dispose() # 关闭数据库连接
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_register(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
error = heartdiseasedataforecast.createbyreq(heartdiseasedataforecast, heartdiseasedataforecast, req_dict)
if error is Exception:
msg['code'] = crud_error_code
msg['msg'] = "用户已存在,请勿重复注册!"
else:
msg['data'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_login(request):
if request.method in ["POST", "GET"]:
msg = {'code': normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
datas = heartdiseasedataforecast.getbyparams(heartdiseasedataforecast, heartdiseasedataforecast, req_dict)
if not datas:
msg['code'] = password_error_code
msg['msg'] = mes.password_error_code
return JsonResponse(msg, encoder=CustomJsonEncoder)
try:
__sfsh__= heartdiseasedataforecast.__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, heartdiseasedataforecast, req_dict)
def heartdiseasedataforecast_logout(request):
if request.method in ["POST", "GET"]:
msg = {
"msg": "登出成功",
"code": 0
}
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_resetPass(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code}
req_dict = request.session.get("req_dict")
columns= heartdiseasedataforecast.getallcolumn( heartdiseasedataforecast, heartdiseasedataforecast)
try:
__loginUserColumn__= heartdiseasedataforecast.__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'
recordsParam = {}
recordsParam[username_str] = req_dict.get("username")
records=heartdiseasedataforecast.getbyparams(heartdiseasedataforecast, heartdiseasedataforecast, recordsParam)
if len(records)<1:
msg['code'] = 400
msg['msg'] = '用户不存在'
return JsonResponse(msg, encoder=CustomJsonEncoder)
eval('''heartdiseasedataforecast.objects.filter({}='{}').update({}='{}')'''.format(username_str,username,password_str,init_pwd))
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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'] = heartdiseasedataforecast.getbyparams(heartdiseasedataforecast, heartdiseasedataforecast, req_dict)[0]
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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=heartdiseasedataforecast.getbyparams(heartdiseasedataforecast, heartdiseasedataforecast, req_dict)
if len(data)>0:
msg['data'] = data[0]
else:
msg['data'] = {}
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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 heartdiseasedataforecast
#获取全部列名
columns= heartdiseasedataforecast.getallcolumn( heartdiseasedataforecast, heartdiseasedataforecast)
if "vipread" in req_dict and "vipread" not in columns:
del req_dict["vipread"]
#当前登录用户所在表
tablename = request.session.get("tablename")
'''__authSeparate__此属性为真，params添加userid，后台只查询个人数据'''
try:
__authSeparate__=heartdiseasedataforecast.__authSeparate__
except:
__authSeparate__=None
if __authSeparate__=="是":
tablename=request.session.get("tablename")
if tablename!="users" and 'userid' in columns and 'userid' not in req_dict:
try:
req_dict['userid']=request.session.get("params").get("id")
except:
pass
#当项目属性hasMessage为”是”，生成系统自动生成留言板的表messages，同时该表的表属性hasMessage也被设置为”是”,字段包括userid（用户id），username(用户名)，content（留言内容），reply（回复）
#接口page需要区分权限，普通用户查看自己的留言和回复记录，管理员查看所有的留言和回复记录
try:
__hasMessage__=heartdiseasedataforecast.__hasMessage__
except:
__hasMessage__=None
if __hasMessage__=="是":
tablename=request.session.get("tablename")
if tablename!="users":
req_dict["userid"]=request.session.get("params").get("id")
# 判断当前表的表属性isAdmin,为真则是管理员表
# 当表属性isAdmin=”是”,刷出来的用户表也是管理员，即page和list可以查看所有人的考试记录(同时应用于其他表)
__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__ == "是" and 'heartdiseasedataforecast' != 'forum' :
if req_dict.get("userid") and 'heartdiseasedataforecast' != 'chat' and 'heartdiseasedataforecast' != 'examrecord':
del req_dict["userid"]
else:
if tablename!="users" and tablename!="jdfnl" and 'heartdiseasedataforecast'[:7]!='discuss' and "userid" in heartdiseasedataforecast.getallcolumn(heartdiseasedataforecast,heartdiseasedataforecast):
req_dict["userid"] = request.session.get("params").get("id")
#当列属性authTable有值(某个用户表)[该列的列名必须和该用户表的登陆字段名一致]，则对应的表有个隐藏属性authTable为”是”，那么该用户查看该表信息时，只能查看自己的
try:
__authTables__=heartdiseasedataforecast.__authTables__
except:
__authTables__=None
if __authTables__!=None and __authTables__!={} and __isAdmin__ == "是":
for authColumn,authTable in __authTables__.items():
if authTable==tablename:
params = request.session.get("params")
req_dict[authColumn]=params.get(authColumn)
username=params.get(authColumn)
break
q = Q()
msg['data']['list'], msg['data']['currPage'], msg['data']['totalPage'], msg['data']['total'], \
msg['data']['pageSize'] =heartdiseasedataforecast.page(heartdiseasedataforecast, heartdiseasedataforecast, req_dict, request, q)
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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 heartdiseasedataforecast.getallcolumn(heartdiseasedataforecast,heartdiseasedataforecast):
req_dict['sort']='clicknum'
elif "browseduration" in heartdiseasedataforecast.getallcolumn(heartdiseasedataforecast,heartdiseasedataforecast):
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'] = heartdiseasedataforecast.page(heartdiseasedataforecast,heartdiseasedataforecast, req_dict)
return JsonResponse(msg, encoder=CustomJsonEncoder)
#分类列表
def heartdiseasedataforecast_lists(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data":[]}
msg['data'],_,_,_,_ = heartdiseasedataforecast.page(heartdiseasedataforecast, heartdiseasedataforecast, {})
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_query(request):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
try:
query_result = heartdiseasedataforecast.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 heartdiseasedataforecast_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= heartdiseasedataforecast.getallcolumn( heartdiseasedataforecast, heartdiseasedataforecast)
if "vipread" in req_dict and "vipread" not in columns:
del req_dict["vipread"]
#表属性[foreEndList]前台list:和后台默认的list列表页相似,只是摆在前台,否:指没有此页,是:表示有此页(不需要登陆即可查看),前要登:表示有此页且需要登陆后才能查看
try:
__foreEndList__=heartdiseasedataforecast.__foreEndList__
except:
__foreEndList__=None
try:
__foreEndListAuth__=heartdiseasedataforecast.__foreEndListAuth__
except:
__foreEndListAuth__=None
#authSeparate
try:
__authSeparate__=heartdiseasedataforecast.__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__=heartdiseasedataforecast.__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 heartdiseasedataforecast.__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'] = heartdiseasedataforecast.page(heartdiseasedataforecast, heartdiseasedataforecast, req_dict, request, q)
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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= heartdiseasedataforecast.getallcolumn( heartdiseasedataforecast, heartdiseasedataforecast)
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= heartdiseasedataforecast.createbyreq(heartdiseasedataforecast,heartdiseasedataforecast, req_dict)
if idOrErr is Exception:
msg['code'] = crud_error_code
msg['msg'] = idOrErr
else:
msg['data'] = idOrErr
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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= heartdiseasedataforecast.getallcolumn( heartdiseasedataforecast, heartdiseasedataforecast)
try:
__authSeparate__=heartdiseasedataforecast.__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__=heartdiseasedataforecast.__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= heartdiseasedataforecast.createbyreq(heartdiseasedataforecast,heartdiseasedataforecast, req_dict)
if error is Exception:
msg['code'] = crud_error_code
msg['msg'] = error
else:
msg['data'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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=heartdiseasedataforecast.getbyid(heartdiseasedataforecast,heartdiseasedataforecast,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 = heartdiseasedataforecast.updatebyparams(heartdiseasedataforecast,heartdiseasedataforecast, update_dict)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_info(request,id_):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
data = heartdiseasedataforecast.getbyid(heartdiseasedataforecast,heartdiseasedataforecast, 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__= heartdiseasedataforecast.__browseClick__
except:
__browseClick__=None
if __browseClick__=="是" and "clicknum" in heartdiseasedataforecast.getallcolumn(heartdiseasedataforecast,heartdiseasedataforecast):
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=heartdiseasedataforecast.updatebyparams(heartdiseasedataforecast,heartdiseasedataforecast,click_dict)
if ret!=None:
msg['code'] = crud_error_code
msg['msg'] = ret
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_detail(request,id_):
'''
'''
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": mes.normal_code, "data": {}}
data =heartdiseasedataforecast.getbyid(heartdiseasedataforecast,heartdiseasedataforecast, 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__= heartdiseasedataforecast.__browseClick__
except:
__browseClick__=None
if __browseClick__=="是" and "clicknum" in heartdiseasedataforecast.getallcolumn(heartdiseasedataforecast,heartdiseasedataforecast):
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=heartdiseasedataforecast.updatebyparams(heartdiseasedataforecast,heartdiseasedataforecast,click_dict)
if ret!=None:
msg['code'] = crud_error_code
msg['msg'] = ret
return JsonResponse(msg, encoder=CustomJsonEncoder)
def heartdiseasedataforecast_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 heartdiseasedataforecast.getallcolumn(heartdiseasedataforecast,heartdiseasedataforecast) :
del req_dict["mima"]
if req_dict.get("password") and "password" not in heartdiseasedataforecast.getallcolumn(heartdiseasedataforecast,heartdiseasedataforecast) :
del req_dict["password"]
try:
del req_dict["clicknum"]
except:
pass
error = heartdiseasedataforecast.updatebyparams(heartdiseasedataforecast, heartdiseasedataforecast, req_dict)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def heartdiseasedataforecast_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=heartdiseasedataforecast.deletes(heartdiseasedataforecast,
heartdiseasedataforecast,
req_dict.get("ids")
)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def heartdiseasedataforecast_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= heartdiseasedataforecast.getbyid(heartdiseasedataforecast, heartdiseasedataforecast, int(id_))
for i in data:
votenum=i.get('votenum')
if votenum!=None:
params={"id":int(id_),"votenum":votenum+1}
error=heartdiseasedataforecast.updatebyparams(heartdiseasedataforecast,heartdiseasedataforecast,params)
if error!=None:
msg['code'] = crud_error_code
msg['msg'] = error
return JsonResponse(msg)
def heartdiseasedataforecast_importExcel(request):
if request.method in ["POST", "GET"]:
msg = {"code": normal_code, "msg": "成功", "data": {}}
excel_file = request.FILES.get("file", "")
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 = {}
heartdiseasedataforecast.createbyreq(heartdiseasedataforecast, heartdiseasedataforecast, req_dict)
except:
pass
else:
msg = {
"msg": "文件类型错误",
"code": 500
}
return JsonResponse(msg)
def heartdiseasedataforecast_autoSort2(request):
return JsonResponse({"code": 0, "msg": '', "data":{}})
1-项目均为博主学习开发自研，适合新手入门和学习使用
2-所有源码均一手开发，不是模版！不容易跟班里人重复！
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
