def choose(stu_id, username):
try:
subjects = session.query(subject).all()
stu_timetable = session.query(timetable).filter_by(id=stu_id).one()
stu_timelist = []
stu_timelist.append(stu_timetable.mon)
stu_timelist.append(stu_timetable.tue)
stu_timelist.append(stu_timetable.wed)
stu_timelist.append(stu_timetable.thu)
stu_timelist.append(stu_timetable.fri)
stu_timelist.append(stu_timetable.sat)
stu_timelist.append(stu_timetable.sun)
subjectlists = []
for i in subjects:
subjectlist = []
subjectlist.append(i.id)
subjectlist.append(i.sub)
subjectlist.append(i.time)
subjectlist.append(i.selected)
if i.sub in stu_timelist:
subjectlist.append('是')
else:
subjectlist.append('否')
subjectlists.append(subjectlist)
return render_template('signin-ok.html',
stu_id=stu_id,
subjects=subjectlists,
username=username)
except Exception as e:
print(e)
def get(self, headers):
# print(dir(Tasks))
data = self.parser.parse_args()
# data.update({"taskExecutorID" : headers["userID"]})
isAdminMode = data.get("isAdminMode")
data.pop("isAdminMode")
if isAdminMode:
if (isAdminMode == "false"):
cdt = {
or_(Task.taskExecutorID == headers["userID"],
Task.taskCreatorID == headers["userID"])
}
else:
#isadmin做筛选时候是有问题的？？
cdt = {Task.taskExecutorID > 0}
else:
cdt = {Task.taskExecutorID == headers["userID"]}
tasksInfo = QueryConductor(data, cdt).queryProcess()
# print(cdt)
# tasksInfo = QueryConductor(data, cdt).queryProcess()
# if not tasksInfo:
# tasksInfo = Task.query.all()
result = TaskSchema().dump(tasksInfo, many=True)
for r in result:
#r["taskBelongedToProjectName"] = session.query(Project).filter_by(projectID=r['taskBelongedToProjectID']).first().projectName
r["taskCreatorName"] = session.query(User).filter_by(
userID=r['taskCreatorID']).first().username
r["taskCreatorRealName"] = session.query(User).filter_by(
userID=r['taskCreatorID']).first().userRealName
r["taskExecutorName"] = session.query(User).filter_by(
userID=r['taskExecutorID']).first().username
if (data.get("taskID")):
return {"statusCode": "1", "task": result}
else:
return {"statusCode": "1", "tasks": result}
def delete(self, headers):
data = self.parser.parse_args()
data_user_id = data.get('userID')
session.query(userProject).filter(
userProject.userID == data_user_id).delete()
session.query(User).filter(User.userID == data_user_id).delete()
#del_by_id = session.query(User).filter_by(userID = data_user_id).first()
#session.delete(del_by_id)
session.commit()
return {"statusCode": "1"}
def delete(self, headers):
data = self.parser.parse_args()
data_user_id = data.get('projectID')
session.query(userProject).filter(
userProject.projectID == data_user_id).delete()
session.query(Project).filter(
Project.projectID == data_user_id).delete()
#del_by_projectID = Project.query.filter(Project.projectID==data_user_id).first()
#db.session.delete(del_by_projectID)
#session.delete(del_by_projectID)
db.session.commit()
return {"statusCode": "1"}
def post(self, headers):
json_data = request.get_json(force=True)
if not json_data:
return {'message': 'No input data provided'}, 400
print(json_data)
#接收的日期格式为2014-08-11T05:26:03.869245
# data, errors = TaskSchema().load(json_data, session=session)
# if errors:
# return errors,422
name = Task.query.filter_by(taskName=json_data['taskName']).first()
if name:
return {'message': 'name already exists'}, 400
#变量如果没有会怎样,需要指定阶段文件？
taskBelongedToProjectName = session.query(Project).filter_by(
projectID=json_data['taskBelongedToProjectID']).first().projectName
taskExecutorRealName = session.query(User).filter_by(
userID=headers['userID']).first().userRealName
task = Task(
taskName=json_data['taskName'],
taskBelongedToProjectID=json_data['taskBelongedToProjectID'],
#belongedToTrialName = json_data['belongedToTrialName'],
taskCreatorID=headers['userID'],
#taskCreatorName = json_data['taskCreatorName'],
taskCreatedTime=time.strftime("%Y-%m-%d", time.localtime()),
taskExecutorID=json_data['taskExecutorID'],
#taskExecutorName = json_data['taskExecutorName'],
taskReceivedStatus=json_data['taskReceivedStatus'],
taskDueTime=json_data['taskDueTime'],
taskProgress=json_data['taskProgress'],
taskCompletedStatus=None,
taskDescription=json_data['taskDescription'],
taskActualCompletedTime=None,
taskBelongedToProjectName=taskBelongedToProjectName,
taskExecutorRealName=taskExecutorRealName)
session.add(task)
session.commit()
executor = User.query.filter(
User.userID == task.taskExecutorID).first()
taskBelongedToProject = Project.query.filter(
Project.projectID == task.taskBelongedToProjectID).first()
sendMail("任务分配通知", executor.userEmail, executor.userRealName,
taskBelongedToProject.projectName, task.taskName,
task.taskDescription, task.taskDueTime.strftime("%Y-%m-%d"))
return {"statusCode": "1", "taskID": task.taskID}
def delete(self):
json_data = request.get_json(force=True)
data_user_id = json_data['studyID']
del_by_id = session.query(Study).filter_by(studyID=data_user_id)
session.delete(del_by_id)
session.commit()
return {'message': 'success'}
def put(self):
json_data = request.get_json(force=True)
data_user_id = json_data['studyID']
update_user = session.query(Study).filter_by(studyID=data_user_id)
update_user.update(json_data)
session.commit()
return {'message': 'success'}
def delete(self, headers):
data = self.parser.parse_args()
data_template_id = data.get('templateID')
del_by_id = session.query(Template).filter_by(templateID=data_template_id).first()
session.delete(del_by_id)
session.commit()
return {"statusCode": "1"}
def delete(self, headers):
data = self.parser.parse_args()
data_user_id = data.get('user_id')
del_by_id = session.query(User).filter_by(user_id=data_user_id).first()
session.delete(del_by_id)
session.commit()
return {'message': 'success'}
def select(stu_id, sub_id):
try:
sub = session.query(subject).filter_by(id=sub_id).one()
stu_timetable = session.query(timetable).filter_by(id=stu_id).one()
if sub.time == 'mon':
stu_time = stu_timetable.mon
elif sub.time == 'tue':
stu_time = stu_timetable.tue
elif sub.time == 'wed':
stu_time = stu_timetable.wed
elif sub.time == 'thu':
stu_time = stu_timetable.thu
elif sub.time == 'fri':
stu_time = stu_timetable.fri
elif sub.time == 'sat':
stu_time = stu_timetable.sat
else:
stu_time = stu_timetable.sun
if not stu_time:
session.query(timetable).filter_by(id=stu_id).update(
{sub.time: sub.sub})
session.commit()
session.query(subject).filter_by(id=sub_id).update(
{'selected': sub.selected + 1})
session.commit()
stu = session.query(student).filter_by(id=stu_id).one()
return redirect(url_for('choose', stu_id=stu_id, username=stu.name))
except Exception as e:
print(e)
def put(self, headers):
data = self.parser.parse_args()
data_user_id = data.get('user_id')
update_user = session.query(User).filter_by(
user_id=data_user_id).first()
update_user.password = data.get('password')
session.commit()
return {'message': 'success'}
def get_all_endpoints(self, id):
for a, e in session.query(
Api, Endpoint).filter(Api.id == Endpoint.api_id).all():
print("Api name: {} Invoice No: {} Amount: {}".format(
a.api_name, e.api_name, e.endpoints))
endpoints = Endpoint.query.all()
endp_schema = EndpointSchema()
endp_schema.dump(Endpoint.query.all())
return endpoints
def update_user(self, _id, new_username, new_password, new_email):
update = session.query(User).filter(User.id == _id).first()
update.username = new_username
session.commit()
update.password = new_password
session.commit()
update.email = new_email
session.commit()
return
def put(self, headers):
json_data = request.get_json(force=True)
data_task_id = json_data['taskID']
update_task = session.query(Task).filter_by(taskID=data_task_id)
update_task.update(json_data)
session.commit()
return {"statusCode": "1"}
def put(self, headers):
json_data = request.get_json(force=True)
data_project_id = json_data['projectID']
update_project = session.query(Project).filter_by(
projectID=data_project_id)
# update_project.projectSponsor = data.get('projectSponsor')
update_project.update(json_data)
session.commit()
return {"statusCode": "1"}
def update_api(self, id, username, name, description):
user = User.query.filter_by(username=username).first()
if user is None:
return # {'error': 'The user does not exist'}, hur????
elif user.username == username:
update = session.query(Api).filter(Api.id == id).first()
update.api_name = name
session.commit()
update.description = description
session.commit()
return
def get(self, headers):
data = self.parser.parse_args()
cdt = {Template.templateCreatorID > 0}
taskTemplatesInfo = QueryConductor(data, cdt).queryProcess()
if not taskTemplatesInfo:
taskTemplatesInfo = Template.query.all()
results = TemplateSchema().dump(taskTemplatesInfo , many=True)
for result in results:
result["templateDownloadURL"] = "/download/"+result["templateDownloadURL"]
result["templateCreatorName"] = session.query(User).filter_by(userID=result['templateCreatorID']).first().username
if result['templateRemoveExecutorID']:
result["templateRemoveExecutorName"] = session.query(User).filter_by(userID=result['templateRemoveExecutorID']).first().username
else:
result["templateRemoveExecutorName"] = ""
if result['templateDeleteExecutorID']:
result["templateDeleteExecutorName"] = session.query(User).filter_by(userID=result['templateDeleteExecutorID']).first().username
else:
result["templateDeleteExecutorName"] = ""
if (data.get("templateID")):
return {"statusCode": "1", "template": results}
else:
return {"statusCode": "1", "templates": results}
def put(self, headers):
json_data = request.get_json(force=True)
data_user_id = json_data['userID']
session.query(userProject).filter(
userProject.userID == data_user_id).delete()
session.commit()
update_user = session.query(User).filter_by(userID=data_user_id)
update_json = json_data.copy()
update_json.pop("userInvolvedProjectsID")
update_json.pop("userCanManageProjectsID")
print(update_json)
update_user.update(update_json)
# session.delete(del_by_id)
#更新方法，变量json_data中的所有数据
# for k in json_data:
# update_user.update({k:json_data[k]})
session.commit()
if json_data["userInvolvedProjectsID"]:
db.session.execute(
userProject.__table__.insert(),
[{
"userID": data_user_id,
"projectID": json_data["userInvolvedProjectsID"][i],
"userType": "2"
} for i in range(len(json_data["userInvolvedProjectsID"]))])
db.session.commit()
if json_data["userCanManageProjectsID"]:
db.session.execute(
userProject.__table__.insert(),
[{
"userID": data_user_id,
"projectID": json_data['userCanManageProjectsID'][i],
"userType": "1"
} for i in range(len(json_data["userCanManageProjectsID"]))])
db.session.commit()
return {"statusCode": "1"}
def get(self, headers):
data = self.parser.parse_args()
if headers["isAdmin"]:
cdt = {File.fileBelongedToTaskID > 0}
else:
taskExeCreateID = Task.query.filter(
*{
or_(Task.taskCreatorID == headers["userID"],
Task.taskExecutorID == headers["userID"])
}).with_entities(Task.taskID).all()
cdt = {File.fileBelongedToTaskID.in_(taskExeCreateID)}
taskFilesInfo = QueryConductor(data, cdt).queryProcess()
results = FileSchema().dump(taskFilesInfo, many=True)
for result in results:
result[
"fileDownloadURL"] = "/download/" + result["fileDownloadURL"]
#result["fileCreatorName"] = session.query(User).filter_by(userID=result['fileCreatorID']).first().username
#result["fileBelongedToTaskName"] = session.query(Task).filter_by(taskID=result['fileBelongedToTaskID']).first().taskName
# result['fileBelongedToProjectID'] = session.query(Task).filter_by(taskID=result['fileBelongedToTaskID']).first().taskBelongedToProjectID
# if result['fileBelongedToProjectID']:
# result["fileBelongedToProjectName"] = session.query(Project).filter_by(projectID=result['fileBelongedToProjectID']).first().projectName
if result['fileRemoveExecutorID']:
result["fileRemoveExecutorName"] = session.query(
User).filter_by(
userID=result['fileRemoveExecutorID']).first().username
if result['fileDeleteExecutorID']:
result["fileDeleteExecutorName"] = session.query(
User).filter_by(
userID=result['fileDeleteExecutorID']).first().username
if result['fileDeleteExecutorID']:
result["fileDeleteExecutorName"] = session.query(
User).filter_by(
userID=result['fileDeleteExecutorID']).first().username
if (data.get("fileID")):
return {"statusCode": "1", "file": results}
else:
return {"statusCode": "1", "files": results}
def signin():
try:
stu_id = request.form['stu_id']
password = request.form['password']
stulist = session.query(student).all()
for i in stulist:
if i.id == stu_id and i.password == password:
return redirect(
url_for('choose', stu_id=stu_id, username=i.name))
return render_template('form.html',
message='Bad username or password',
stu_id=stu_id)
except Exception as e:
print(e)
def post(self, headers):
data = self.parser.parse_args()
print(data)
# json_data = request.get_json(force=True)
# if not json_data:
# return {'message': 'No input data provided'}, 400
# data, errors = taskTemplatesSchema().load(json_data)
# if errors:
# return errors,422
# sop_name = taskTemplates.query.filter_by(sop_name=json_data['sop_name']).first()
# if sop_name:
# return {'message': 'taskTemplate already exists'}, 400
#变量如果没有会怎样,需要指定阶段文件？
template = request.files['template']
if not template:
return {'message': 'No input template provided'}, 400
template_name = Template.query.filter_by(templateName=data.get('templateName')).first()
template_URL = Template.query.filter_by(templateDownloadURL=template.filename).first()
templateCreatorRealName = session.query(User).filter_by(userID=headers["userID"]).first().userRealName
taskTemplate = Template(
templateName=data.get('templateName'),
templateDescription = data.get('templateDescription'),
templateCreateDate = time.ctime(time.time()),
templateCreatorID = headers["userID"],
templateStatus = data.get('templateStatus'),
templateRemoveDate = None,
templateRemoveExecutorID = None,
templateDeleteDate = None,
templateDeleteExecutorID = None,
templateDownloadURL = template.filename,
templateCreatorRealName = templateCreatorRealName
)
if template_name:
return {'message': 'taskTemplate already exists'}, 400
if template_URL:
return {'message': 'Template file already exists, please rename'}, 400
#略掉中文字符,文件不要有中文字符
# templatename = secure_templatename(template.templatename)
template.save(os.path.join('./static/', template.filename))
session.add(taskTemplate)
session.commit()
#return {'message': 'template save error'}, 400
return {"statusCode": "1"}
def put(self, headers):
# json_data = request.get_json(force=True)
data = self.parser.parse_args()
data_template_id = data.get('templateID')
update_template = session.query(Template).filter_by(templateID=data_template_id).first()
if data.get('templateName'):
update_template.templateName = data.get('templateName')
if data.get('templateDescription'):
update_template.templateDescription = data.get('templateDescription')
if data.get('templateStatus'):
update_template.templateStatus = data.get('templateStatus')
if data.get('templateStatus') == "2":
update_template.templateRemoveExecutorID = headers["userID"]
update_template.templateRemoveDate = time.ctime(time.time())
# 更新方法，变量json_data中的所有数据
# for k in json_data:
# update_user.update({k:json_data[k]})
session.commit()
return {"statusCode": "1"}
def get(self, headers):
#title必须大于5个字
#文件内容模板
#sendMail("求职soopooo", "*****@*****.**")
data = self.parser.parse_args()
#获得用户信息
cdt = {User.userID > 0}
userInfo = QueryConductor(data, cdt).queryProcess()
if not userInfo:
userInfo = User.query.all()
results = UserSchema().dump(userInfo, many=True)
for result in results:
# list->dict
# for i, k in enumerate(result):
# result = k
#获得指定用户参与的所有项目信息
result["userInvolvedProjectsID"] = []
result["userInvolvedProjectsName"] = []
result["userCanManageProjectsID"] = []
result["userCanManageProjectsName"] = []
user_projectInfo = userProject.query.filter_by(
userID=result["userID"]).all()
result_user_project = userProjectSchema().dump(user_projectInfo,
many=True)
print(result_user_project)
for r in result_user_project:
r["projectName"] = session.query(Project).filter_by(
projectID=r['projectID']).first().projectName
result["userInvolvedProjectsID"].append(r["projectID"])
result["userInvolvedProjectsName"].append(r["projectName"])
if (r["userType"] == 1):
result["userCanManageProjectsID"].append(r["projectID"])
result["userCanManageProjectsName"].append(
r["projectName"])
if (data.get("userID")):
return {"statusCode": "1", "user": results}
else:
return {"statusCode": "1", "users": results}
def put(self, headers):
# json_data = request.get_json(force=True)
data = self.parser.parse_args()
data_file_id = data.get("fileID")
# data_file_id = json_data['fileID']
update_file = session.query(File).filter_by(
fileID=data_file_id).first()
if data.get('fileName'):
update_file.fileName = data.get('fileName')
if data.get('fileDescription'):
update_file.fileDescription = data.get('fileDescription')
if data.get('fileStatus'):
update_file.fileStatus = data.get('fileStatus')
if data.get('fileStatus') == "2":
update_file.fileRemoveID = headers["userID"]
update_file.fileRemoveDate = time.ctime(time.time())
# update_file.update()
# 更新方法，变量json_data中的所有数据
# for k in json_data:
# update_user.update({k:json_data[k]})
session.commit()
return {"statusCode": "1"}
def post(self, headers):
data = self.parser.parse_args()
print(data)
# json_data = request.get_json(force=True)
# if not json_data:
# return {'message': 'No input data provided'}, 400
# data, errors = taskFilesSchema().load(json_data)
# if errors:
# return errors,422
# sop_name = taskFiles.query.filter_by(sop_name=json_data['sop_name']).first()
# if sop_name:
# return {'message': 'taskFile already exists'}, 400
#变量如果没有会怎样,需要指定阶段文件？
file = request.files['file']
if not file:
return {'message': 'No input file provided'}, 400
file_name = File.query.filter_by(fileName=data.get('fileName')).first()
file_URL = File.query.filter_by(fileDownloadURL=file.filename).first()
fileBelongedToTaskName = session.query(Task).filter_by(
taskID=data.get('fileBelongedToTaskID')).first().taskName
fileBelongedToProjectName = session.query(Project).filter_by(
projectID=data.get('fileBelongedToProjectID')).first().projectName
fileCreatorName = session.query(User).filter_by(
userID=headers["userID"]).first().username
taskFile = File(
fileName=data.get('fileName'),
fileDescription=data.get('fileDescription'),
fileBelongedToTaskID=data.get('fileBelongedToTaskID'),
fileBelongedToProjectID=data.get('fileBelongedToProjectID'),
fileCreateDate=time.ctime(time.time()),
fileCreatorID=headers["userID"],
fileStatus=data.get('fileStatus'),
fileRemoveDate=None,
fileRemoveExecutorID=None,
fileDeleteDate=None,
fileDeleteExecutorID=None,
fileDownloadURL=file.filename,
fileBelongedToTaskName=fileBelongedToTaskName,
fileBelongedToProjectName=fileBelongedToProjectName,
fileCreatorName=fileCreatorName
# fileName = data.get('fileName'),
# createDate = data.get('createDate'),
# creatorID = data.get('creatorID'),
# # self.creatorName = creatorName
# description = data.get('description'),
# deleteDate = data.get('deleteDate'),
# deleteExecutorID = data.get('deleteExecutorID'),
# # self.deleteExecutorName = deleteExecutorName
# downloadURL = file.filename
)
if file_name:
return {'message': 'taskFile already exists'}, 400
if file_URL:
return {'message': 'File already exists, please rename'}, 400
#略掉中文字符,文件不要有中文字符
# filename = secure_filename(file.filename)
file.save(os.path.join('./static/', file.filename))
session.add(taskFile)
session.commit()
#return {'message': 'file save error'}, 400
return {"statusCode": "1"}
def get(self, headers):
print(headers)
data = self.parser.parse_args()
# cdt = {Project.projectID > 0}
# studyInfo = QueryConductor(data, cdt).queryProcess()
# if not studyInfo:
# studyInfo = Project.query.all()
# results = ProjectSchema().dump(studyInfo, many=True)
if headers["isAdmin"]:
cdt = {Project.projectID > 0}
else:
userProjectID = userProject.query.filter(
*{userProject.userID == headers["userID"]}).with_entities(
userProject.projectID).distinct().all()
cdt = {Project.projectID.in_(userProjectID)}
studyInfo = QueryConductor(data, cdt).queryProcess()
results = ProjectSchema().dump(studyInfo, many=True).data
# projectID = None
# for i, k in enumerate(result):
# projectID = k["projectID"]
#传入的peojectID或者isAdmin
# if (headers["isAdmin"] or data.get("projectID")):
for result in results:
result["projectInvolvedUsersID"] = []
result["projectInvolvedUsersName"] = []
user_projectInfo = userProject.query.filter_by(
projectID=result["projectID"]).all()
result_user_project = userProjectSchema().dump(user_projectInfo,
many=True).data
print(result_user_project)
if len(results) == 1:
like_filters = {}
like_filters["projectID"] = result["projectID"]
like_filters["userType"] = 1
manager = userProject.query.filter_by(**like_filters)
print(manager.first())
if manager.first():
result["projectManagerID"] = manager.first().userID
result["projectManagerName"] = session.query(
User).filter_by(
userID=manager.first().userID).first().username
for r in result_user_project:
r["username"] = session.query(User).filter_by(
userID=r["userID"]).first().username
if (r["userType"] == 2):
result["projectInvolvedUsersID"].append(r["userID"])
result["projectInvolvedUsersName"].append(
r["username"])
#传入userID
# else:
# results = []
# user_projectInfo = userProject.query.filter_by(userID=headers["userID"], userType=2).all()
# result_user_project = userProjectSchema().dump(user_projectInfo, many=True)
# for i in result_user_project:
# studyInfo = Project.query.filter_by(projectID = i["projectID"])
# results.append(ProjectSchema().dump(studyInfo, many=True)[0])
# return { "statusCode": "1", 'project':results}
if (data.get("projectID")):
return {"statusCode": "1", "project": results}
else:
return {"statusCode": "1", "projects": results}
def change_email(self, id, email):
session.query(User).filter(User.id == id).update({'email': email})
session.commit()
return
def change_password(self, id, password):
session.query(User).filter(User.id == id).update(
{'password': password})
session.commit()
return
def change_username(self, id, username):
session.query(User).filter(User.id == id).update(
{'username': username})
session.commit()
return
def delete_user(self, id):
user = session.query(User).get(id)
session.delete(user)
session.commit()
return
