1570 lines
84 KiB
Python
1570 lines
84 KiB
Python
from tools import *
|
||
from Utils.Config import *
|
||
from Utils.Lib import *
|
||
"""
|
||
|
||
已被废弃，仅供参考
|
||
|
||
"""
|
||
|
||
Manage=flask.Blueprint("Manage", __name__, static_folder = JoinPath(FlaskTempLate, "Manage"), static_url_path = "/", subdomain = "manage")
|
||
|
||
#response = client.chat.completions.create(
|
||
# model="deepseek-chat",
|
||
# messages=[
|
||
# {"role": "system", "content": "You are a helpful assistant"},
|
||
# {"role": "user", "content": "你好"},
|
||
# ],
|
||
# stream=False
|
||
#)
|
||
#print(response.choices[0].message.content)
|
||
|
||
#https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=ww36e7f50aa690169a&corpsecret=-r2vvpDpqX8DIUbHOuA5GjEyiniWLrSFfnKNyvZ88yQ
|
||
access_token="DpsH1Vt9Hg7cd-4VGQij2zQ9fQ7G9sREK5ugxs52bDUA46f3tJLjVxzbkqxFG91WRRlL7GaEdAx1E5UPAgL7O05psZqDQK8wm3OWR4ixLvx4M2LU6Pi5UfgqhKi53mhKe1IyxbOJLNkT7BdnYBW2WgKXO8mlhC6_jqpQgKDrDKF7U0i1KU9B6ZWlGlJz06caeK7J5ji4ADqheCokL2oByw"
|
||
|
||
def GetWeekStartDate(day=None, week_start=0, week_seek=0):
|
||
if week_seek != 0:
|
||
day = date.today()
|
||
day += timedelta(weeks=week_seek)
|
||
else: day = day or date.today()
|
||
return (day - timedelta(days=(day.weekday() - week_start) % 7)).strftime('%Y-%m-%d 00:00:00')
|
||
|
||
def PermissionsToStrPermissions(ADMIN):
|
||
ADMIN = str(ADMIN)
|
||
if "." not in ADMIN:return "未知"
|
||
main, sub = ADMIN.split(".", 1)
|
||
permissions_map = {
|
||
"5": ["工作室创始人", {
|
||
"0": "",
|
||
"2": "(没有认真阅读文档加入)(这个状态码在工作室创始人换人前不会出现)",
|
||
"9": "(劳动合同未签署或失效)(这个状态码在工作室创始人换人前不会出现)",
|
||
}],
|
||
"4": ["组代理", {
|
||
"01": "(临时)",
|
||
"0": "",
|
||
"5": "(4~5的中间级)(正常情况下不会出现)"
|
||
}],
|
||
"3": ["委代理", {
|
||
"01": "(临时)",
|
||
"0": ""
|
||
}],
|
||
"2": ["", {
|
||
"0": "组员",
|
||
"5": "组长",
|
||
"9": "特权"
|
||
}],
|
||
"1": ["", {
|
||
"0": "网站注册人员/普通人员/测试用户/工作室用户暂时权限未更改"
|
||
}],
|
||
}
|
||
invalid_msg = f"{main}没有这个状态码"
|
||
if main not in permissions_map: return "未知"
|
||
if sub in permissions_map[main][1]: return permissions_map[main][0] + permissions_map[main][1].get(sub)
|
||
else: return invalid_msg
|
||
|
||
TaskTypeLib={"1":"图像（纯图像文件）","2":"图像工程文件","3":"视频（纯视频文件）","4":"视频工程文件","5":"代码源文件","6":"编译后文件（exe）","7":"编译后文件（elf）","8":"编译后文件（app）","9":"编译后文件（apk）","10":"编译后文件（其它）（库文件）","11":"网络资源文件（exe）","12":"网络资源文件（elf）","13":"网络资源文件（app）","14":"网络资源文件（apk）","15":"网络资源文件（其它）（库文件）","16":"文稿（纯文字）","17":"文稿（网页文件）（富文本）（HTML5）","18":"文稿（标记语言）（MarkDown）","19":"文稿（故事剧情）","20":"停职恢复考察"}
|
||
TaskAnswerLib={"1":"上传文件","2":"填写长信息（多次换行）","3":"填写短信息（不可换行）","4":"填写链接","5":"其它链接（如考试题答题界面链接）"}
|
||
def LISTTOTASKTYPE(I):
|
||
s=[]
|
||
for i in I:
|
||
if str(i) in TaskTypeLib:s.append(TaskTypeLib[str(i)])
|
||
else:s.append("未知")
|
||
return s
|
||
def LISTTOTASKANSWER(I):
|
||
s=[]
|
||
for i in I:
|
||
if str(i) in TaskAnswerLib:s.append(TaskAnswerLib[str(i)])
|
||
else:s.append("未知")
|
||
return s
|
||
|
||
def INTTOTASKTYPE(I):
|
||
if I in TaskTypeLib:return TaskTypeLib[I]
|
||
else:return "未知"
|
||
def INTTOTASKANSWER(I):
|
||
if I in TaskAnswerLib:return TaskAnswerLib[I]
|
||
else:return "未知"
|
||
|
||
|
||
"""def GetSMTM():
|
||
res=[]
|
||
for i in SQLUsers.selectashead(NSQL.MOD.ALL,FROM="SMTM"):
|
||
if not Is_User(GetBytesto16(i["UserUUID"])):
|
||
SQLUsers.delete(FROM="UserSub", WHERE=("UserUUID=%s", i["UserUUID"]))
|
||
continue
|
||
res.append({"UserUUID":GetBytesto16(i["UserUUID"]), "UserParent": GetBytesto16(i["UserParent"])})
|
||
return res
|
||
|
||
def SearchChilds(UUID: str, SMTM):
|
||
if not UUID or not SMTM:
|
||
return False
|
||
l=[]
|
||
for i in SMTM:
|
||
if i["UserParent"] == UUID:
|
||
l.append(i["UserUUID"])
|
||
return l
|
||
|
||
def SearchFutureGenerations(UUID: str, SMTM):
|
||
# 搜索某个UUID在SMTM下的所有子类
|
||
ASMTM=GetSMTM()
|
||
d={str(SearchChilds("0"*32, ASMTM)[0]):{"Member":{}}}
|
||
def Recursion(d, U):
|
||
for i in SearchChilds(U, SMTM):
|
||
d["Member"][i]=Recursion({"Member": {}}, i)
|
||
return d
|
||
for i in SearchChilds(UUID, SMTM):
|
||
d[SearchChilds("0"*32, ASMTM)[0]]["Member"][i]=Recursion({"Member": {}}, i)
|
||
return d"""
|
||
|
||
def GetSMTM():
|
||
result = []
|
||
for user in SQLUsers.selectashead(NSQL.MOD.ALL, FROM="SMTM"):
|
||
UserUUID = GetBytesto16(user["UserUUID"])
|
||
#if not Is_User(userUuid):
|
||
# SQLUsers.delete(FROM="UserSub", WHERE=("UserUUID=%s", user["UserUUID"]))
|
||
# continue
|
||
result.append({"UserUUID": UserUUID, "UserParent": GetBytesto16(user["UserParent"])})
|
||
return result
|
||
def SearchChilds(UserUUID, smtm):
|
||
if not UserUUID or not smtm: return False
|
||
return [child["UserUUID"] for child in smtm if child["UserParent"] == UserUUID]
|
||
def SearchFutureGenerations(UserUUID, smtm):
|
||
if not UserUUID or not smtm: return {}
|
||
RootUUID = SearchChilds("0"*32, smtm)[0]
|
||
result = {RootUUID: {"Member": {}}}
|
||
directChildren = SearchChilds(UserUUID, smtm)
|
||
if not directChildren: return result
|
||
stack = [(childUuid, result[RootUUID]["Member"]) for childUuid in directChildren]
|
||
while stack:
|
||
currentUuid, parentMember = stack.pop()
|
||
currentMember = {"Member": {}}
|
||
parentMember[currentUuid] = currentMember
|
||
children = SearchChilds(currentUuid, smtm)
|
||
for childUuid in children:
|
||
stack.append((childUuid, currentMember["Member"]))
|
||
return result
|
||
|
||
# Tasks
|
||
def Is_Task(u):
|
||
return SQLTasks.istrue("Tasks", ("TaskUUID=%s", Get16toBytes(u)))
|
||
def Is_UserInTask(u, UserUUID):
|
||
return SQLTasks.istrue("Answer", ("TaskUUID=%s AND UserUUID=%s" , (Get16toBytes(u), Get16toBytes(UserUUID))))
|
||
def GetTaskInFo(u):
|
||
return SQLTasks.selectashead(NSQL.MOD.ALL, FROM="Tasks", WHERE=("TaskUUID=%s", Get16toBytes(u)), _limit=1)[0]
|
||
def GetTaskAnswerInFo(TaskUUID, UserUUID):
|
||
return SQLTasks.selectashead(NSQL.MOD.ALL, FROM="Answer", WHERE=("TaskUUID=%s AND UserUUID=%s", (Get16toBytes(TaskUUID), Get16toBytes(UserUUID))), _limit=1)[0]
|
||
def GetTaskUsers(u):
|
||
return SQLTasks.selectashead(NSQL.MOD.ALL, FROM="Answer", WHERE=("TaskUUID=%s", Get16toBytes(u)))
|
||
def GetTaskUserInFo(u, UserUUID):
|
||
return SQLTasks.selectashead(NSQL.MOD.ALL, FROM="Answer", WHERE=("TaskUUID=%s AND UserUUID=%s", (Get16toBytes(u), Get16toBytes(UserUUID))), _limit=1)[0]
|
||
def GetTasksByOne(UserUUID):
|
||
return SQLTasks.selectashead(NSQL.MOD.ALL, FROM="Tasks", WHERE=("TaskPublisher=%s", Get16toBytes(UserUUID)))
|
||
def GetTasksNeedDo(UserUUID):
|
||
return SQLTasks.selectashead(NSQL.MOD.ALL, FROM="Answer", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)))
|
||
|
||
#占用额外资源，可以给删了
|
||
def GetTaskAlowDev(TaskUUID, UserUUID):
|
||
return UserUUID == GetBytesto16(GetTaskInFo(TaskUUID)["TaskPublisher"]) or SubIsIn(UserUUID, GetBytesto16(GetTaskInFo(TaskUUID)["TaskPublisher"]))
|
||
|
||
def SubIsInOrIs(ParentUUID, SubUserUUID):
|
||
return ParentUUID == SubUserUUID or SubIsIn(ParentUUID, SubUserUUID)
|
||
|
||
|
||
|
||
def SearchParent(UUID: str, SMTM):
|
||
if not UUID or not SMTM:return False
|
||
for i in SMTM:
|
||
if "UserParent" in i and "UserUUID" in i and i["UserUUID"] == UUID: return i["UserParent"]
|
||
return False
|
||
|
||
def SubIsIn(ParentUUID,SubUserUUID):
|
||
s=0
|
||
ASMTM=GetSMTM()
|
||
while True:
|
||
if (SubUserUUID:=SearchParent(SubUserUUID, ASMTM)) == ParentUUID: return True
|
||
if SubUserUUID == "0"*32: return False
|
||
if s == 500: return False
|
||
s+=1
|
||
|
||
def SearchAndDelChildRen(Member: list, LDI: str):
|
||
indices = [int(index) for index in LDI.split("-")]
|
||
current_list = Member
|
||
for index in indices[:-1]:
|
||
current_list = current_list[index]["Member"]
|
||
del current_list[indices[-1]]
|
||
return current_list
|
||
|
||
def Str2Sex(c):
|
||
if c == -1: return "未更改"
|
||
elif c == 1: return "男"
|
||
elif c == 0: return "女"
|
||
else: return "错误"
|
||
|
||
def PersonnelTemplate(UUID, MEMB, SmtmUser):
|
||
res={}
|
||
c=next((item for item in SmtmUser if GetBytesto16(item["UserUUID"]) == UUID), None)
|
||
#c=ReadUserConfig(UUID)
|
||
res["name"]=c["UserName"]
|
||
res["UserJobNumber"]=GetBytesto16(c["UserJobNumber"]) if c["UserJobNumber"] else "未启用工号"
|
||
res["UserRealName"]=c["UserRealName"]
|
||
res["UserSex"]=Str2Sex(c["UserSex"])
|
||
res["UserUUID"]=GetBytesto16(c["UserUUID"])
|
||
res["UserHeadPng"]="https://ugm.gvsds.com/GetArgsUserHeadPng.api?UserUUID="+res["UserUUID"]
|
||
res["UserPermissions"]=c["UserPermissions"]
|
||
res["UserPermissionstr"]=PermissionsToStrPermissions(c["UserPermissions"])
|
||
res["UserJob"]=c["UserJob"]
|
||
res["UserLastCheckInDate"]=c["UserLastCheckInDate"].strftime("%Y-%m-%d %H:%M:%S") if c["UserLastCheckInDate"] else "从未签到"
|
||
if c["UserPositionStatus"] == 1: res["UserPositionStatus"]="在职"
|
||
elif c["UserPositionStatus"] == 0: res["UserPositionStatus"]="停职"
|
||
elif c["UserPositionStatus"] == 2: res["UserPositionStatus"]="在职合作"
|
||
elif c["UserPositionStatus"] == 3: res["UserPositionStatus"]="停职合作"
|
||
else: res["UserPositionStatus"]="未知代码"
|
||
if "Member" in MEMB and MEMB["Member"] != {}:
|
||
res["type"]=4
|
||
res["children"]=[]
|
||
for i in MEMB["Member"]:
|
||
res["children"].append(PersonnelTemplate(i, MEMB["Member"][i], SmtmUser))
|
||
res["isParent"]=True
|
||
else:
|
||
res["type"]=6
|
||
res["children"]=[]
|
||
res["isParent"]=False
|
||
return res
|
||
|
||
class _i18n:
|
||
def __init__(self): pass
|
||
#def __getattribute__(self, name): pass
|
||
def __t(self, args1, *args2): return f"{", ".join(args1+args2)}" # TempLateMore
|
||
def illegal(self, *args): return "%s 违法" % self.__t(args)
|
||
def DataError(self, Name, Type): return "%s 应当为 %s 类型" % (Name, Type)
|
||
#User
|
||
def NoUser(self, *args): return "%s 用户不存在" % self.__t(args)
|
||
def NoIn(self, ParentUser, SubUser): return "%s 不受 %s 管理" % (ParentUser, SubUser)
|
||
def NoPower(self, Permission): return "无 %s 操作权限" % Permission
|
||
# Task
|
||
def NoTask(self, *args): return "%s 任务不存在" % self.__t(args)
|
||
def NoAnswer(self, *args): return "%s 成员任务回答不存在" % self.__t(args)
|
||
# PersonPage
|
||
YouNeverRegisterPersonalPage="你没有注册过个人主页，填写并提交表单以应用"
|
||
# Other
|
||
def NoParameter(self, *args): return "%s 参数不存在" % self.__t(args)
|
||
def NoUUID(self, Name): return "%s 不符合 UUID 格式" % Name
|
||
def Abnormal(self, *args): return "%s 异常" % self.__t(args)
|
||
def NoFound(self, *args): return "%s 不存在" % self.__t(args)
|
||
def NotLegalChar(self, Name): return "%s 含有禁止字符" % Name
|
||
def TooBigMsg(self, Name, Max): return "%s 过大，理应不超过 %s" % (Name, Max)
|
||
def BeMostValue(self, Name): return "%s 为必填项" % Name
|
||
def NotAZ09(self, Name): return "%s 只允许大写字母、数字和下划线" % Name
|
||
def Notaz09(self, Name): return "%s 只允许小写字母、数字和下划线" % Name
|
||
def NotAZaz09(self, Name): return "%s 只允许字母、数字和下划线" % Name
|
||
def AgainstSystem(self, Name): return "%s 占用系统资源" % Name
|
||
def Repeat(self, Name): return "%s 重复" % Name
|
||
CodeError="状态码异常"
|
||
AddSuccess="添加成功"
|
||
AddError="添加失败"
|
||
DelSuccess="删除成功"
|
||
DelError="删除失败"
|
||
OperateSuccess="操作成功"
|
||
OperateError="操作失败"
|
||
RegisterSuccess="注册成功"
|
||
RegisterError="注册失败"
|
||
ChangeSuccess="修改成功"
|
||
ChangeError="修改失败"
|
||
AdminMode="管理模式"
|
||
NoTime="无时间"
|
||
ModeError="模式错误"
|
||
Yes="是"
|
||
No="否"
|
||
GetError="数据取值异常"
|
||
NoPermission="无权限"
|
||
TooBig="数据过大"
|
||
AlreadyExist="已存在"
|
||
NotExist="不存在"
|
||
Cancelled="已注销"
|
||
# Task
|
||
ThisTaskNotBelongToYou="你无需做这个任务，这个任务不属于你"
|
||
YouVeSubmitted="你已提交该任务"
|
||
YouDontHavePermissionToperate="你无权操作该任务"
|
||
YouDontHavaPermissionToSeeit="你无权查看"
|
||
TaskTimeOut="任务已超时"
|
||
TaskAlreadyExist="任务已存在"
|
||
TimeAbnormal="时间戳异常"
|
||
TimeBeMostOver2Hour="任务时间必须大于2小时"
|
||
# Score
|
||
InitialAssessmentScore="初始考核分"
|
||
LWSIAWU="上上周签到考核不合格"#Last week, the sign-in assessment was unqualified
|
||
LWSAF="上周签到考核不合格"#Last week's sign-in assessment failed
|
||
# CheckIn
|
||
CheckInError="签到失败！CSRF无效，也许您应该刷新网页！"
|
||
AlreadyCheckIn="您已签到"
|
||
i18n=_i18n()
|
||
|
||
"""
|
||
API统一管理
|
||
|
||
验证所有参数是否为None
|
||
验证所有参数是否达到最基本的合法（UUID）
|
||
验证所有参数是否合法
|
||
做好SMTM继承保护
|
||
_limit=1必要条件
|
||
if not _ 必要条件才能执行取0
|
||
if None：赋值直接在get里写
|
||
|
||
执行
|
||
返回
|
||
"""
|
||
|
||
|
||
#给删了
|
||
def HightLight(l, s=" "):
|
||
return s.join(list(map(lambda x: '<span class="layui-btn layui-btn-normal layui-btn-mini">%s</span>' % x, l)))
|
||
|
||
#给删了
|
||
def GetUserPositionStatusStr(UserPositionStatus):
|
||
if UserPositionStatus == 1: return "<span class=\"layui-btn layui-btn-normal layui-btn-mini\">在职</span>"
|
||
else: return "<span class=\"layui-btn layui-btn-danger layui-btn-mini layui-btn-disabled\">停职</span>"
|
||
|
||
|
||
@Manage.route("/")
|
||
def ManageIndex():
|
||
UserConfig=GetELTUserConfig()
|
||
return flask.render_template("/Manage/index.html",
|
||
UserName=StrMinus(UserConfig["UserName"], 15),
|
||
UserPersonalSignature=StrMinus(UserConfig["UserPersonalSignature"], 15),
|
||
UserEmail=StrMinus(UserConfig["UserEmail"], 15),
|
||
UserPermissions=float(UserConfig["UserPermissions"]),
|
||
UserJob=UserConfig["UserJob"],
|
||
UserBook=False if flask.request.args.get("UserBook") else True)
|
||
|
||
@Manage.route("/index.html")
|
||
def MainIndexHtml():
|
||
return flask.redirect(flask.url_for("Manage.ManageIndex"))
|
||
|
||
@Manage.route("/User/ChangePasswd.html")
|
||
def UserChangePasswd():
|
||
return flask.render_template("/Manage/User/ChangePasswd.html")
|
||
|
||
@Manage.route("/API/UserHeadCard.api")
|
||
def UserHeadCard():
|
||
UserConfig=GetELTUserConfig()
|
||
return {"UserHeadCard_UserName": StrMinus(UserConfig["UserName"], 15),
|
||
"UserHeadCard_UserPersonalSignature": StrMinus(UserConfig["UserPersonalSignature"], 15),
|
||
"UserHeadCard_UserEmail": StrMinus(UserConfig["UserEmail"], 15)}
|
||
|
||
@Manage.route("/API/IdCard.api")
|
||
@PreRequirements(1.0)
|
||
def UserIdCard():
|
||
UserConfig=GetELTUserConfig()
|
||
return {"UserName": UserConfig["UserName"],
|
||
"UserRealName": UserConfig["UserRealName"],
|
||
"UserUUID": GetBytesto16(UserConfig["UserUUID"]),
|
||
"UserPermissions": float(UserConfig["UserPermissions"]),
|
||
"UserStrPermissions": PermissionsToStrPermissions(float(UserConfig["UserPermissions"])),
|
||
"UserJob": UserConfig["UserJob"],
|
||
"UserPosition": UserConfig["UserPositionStatus"]}
|
||
|
||
@Manage.route("/API/SubMemIdCard.api")
|
||
@PreRequirements(1.0, mod=[PRMODS.OVERPERMISSION], c="ag/UserUUID")
|
||
def UserSubMemIdCardAPI():
|
||
UserUUID=flask.request.args.get("UserUUID")
|
||
if not Is_User(UserUUID): return {"code":1,"msg":"NOT USER"}
|
||
UserConfig=ReadUserConfig(UserUUID)
|
||
return {"code":0,
|
||
"UserName": GetUUIDUser(UserUUID),
|
||
"UserRealName": UserConfig["UserRealName"],
|
||
"UserSex": Str2Sex(UserConfig["UserSex"]),
|
||
"UserUUID": UserUUID,
|
||
"UserPermissions": UserConfig["UserPermissions"],
|
||
"UserStrPermissions": PermissionsToStrPermissions(UserConfig["UserPermissions"]),
|
||
"UserJob": UserConfig["UserJob"],
|
||
"UserPosition": UserConfig["UserPositionStatus"]}
|
||
|
||
@Manage.route("/API/GetSubMem.api")
|
||
@PreRequirements(2.0)
|
||
def UserGetSubMemApi():
|
||
SMTM=GetSMTM()
|
||
User=SearchFutureGenerations(GetELTUserUUID(), SMTM)
|
||
SmtmUser=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="UserSub", WHERE=("UserPermissions>=2.0"))
|
||
if User == False: User={"Member":[]}
|
||
data=[]
|
||
for i in (Member:=User[SearchChilds("0"*32, SMTM)[0]]["Member"]):
|
||
data.append(PersonnelTemplate(i, Member[i], SmtmUser))
|
||
return flask.jsonify({"code":0, "count":1000, "data":data})
|
||
|
||
@Manage.route("/API/SetPositionStatus.api", methods=["POST"])
|
||
@PreRequirements(1.0)
|
||
def UserRePositionStatus():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
Code=flask.request.form.get("Code")
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if Code not in ["1","0"]: return {"code":1,"msg":i18n.CodeError}
|
||
if not Is_User(UserUUID): return {"code":1,"msg":i18n.NoUser("UserUUID")}
|
||
if not SubIsIn(GetELTUserUUID(), UserUUID): return {"code":1,"msg":i18n.NoIn("ELTUserUUID", "UserUUID")}
|
||
WriteUserConfigI(UserUUID, "UserPositionStatus", Code)
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/AddChildRen.api", methods=["POST"])
|
||
def UserAddChildRen():
|
||
ELTUserUUID=GetELTUserUUID()
|
||
SubUserUUID=flask.request.form.get("SubUserUUID")
|
||
ParentUserUUID=flask.request.form.get("ParentUserUUID", ELTUserUUID)
|
||
if not Is_UUID(SubUserUUID): return {"code":1,"msg":i18n.NoUUID("SubUserUUID")}
|
||
if not Is_UUID(ParentUserUUID): return {"code":1,"msg":i18n.NoUUID("ParentUserUUID")}
|
||
if not Is_User(SubUserUUID): return {"code":1,"msg":i18n.NoUser("SubUserUUID")}
|
||
if not Is_User(ParentUserUUID): return {"code":1,"msg":i18n.NoUser("ParentUserUUID")}
|
||
# if not SubIsIn(ELTUserUUID, SubUserUUID): return {"code":1,"msg":i18n.NoIn("ELTUserUUID", "SubUserUUID")}
|
||
# if not SubIsInOrIs(ELTUserUUID, ParentUserUUID): return {"code":1,"msg":i18n.NoIn("ELTUserUUID", "ParentUserUUID")}
|
||
if GetELTUserPermissions() < 4.0: return {"code":1,"msg":i18n.NoPower(4.0)}
|
||
SQLUsers.delete("SMTM", WHERE=("UserUUID=%s", Get16toBytes(SubUserUUID)))
|
||
SQLUsers.insert("SMTM", UserUUID=Get16toBytes(SubUserUUID), UserParent=Get16toBytes(ParentUserUUID))
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
|
||
@Manage.route("/Post/SubMemberManagementDelete.api", methods=["POST"])
|
||
@PreRequirements(2.0)
|
||
def UserSubMemberManagementDeleteApi():# 调试!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
|
||
#LDI=flask.request.form.get("LAY_DATA_INDEX")
|
||
#_=GetSMTM()
|
||
#_["Member"]=SearchAndDelChildRen(Search(GetSMTM()["Member"],GetELTUserUUID())["Member"],LDI)
|
||
#print(_)
|
||
return "1"
|
||
|
||
|
||
@Manage.route("/Takes/TaskFinish.html")
|
||
@PreRequirements(1.0)
|
||
def UserTaskFinish():
|
||
if Is_Task((TaskUUID:=flask.request.args.get("TaskUUID"))): return flask.render_template("/Manage/TaskFinish.html",TaskName=GetTaskInFo(TaskUUID)["TaskName"],TaskUUID=TaskUUID)
|
||
flask.abort(404)
|
||
|
||
@Manage.route("/Tasks/TaskToDo.html")
|
||
@PreRequirements(1.0)
|
||
def UserTaskToDo():
|
||
TaskUUID=flask.request.args.get("TaskUUID")
|
||
if TaskUUID==None:
|
||
return "Error: TaskUUID Is None"
|
||
if not Is_Task(TaskUUID):
|
||
return "Error: UUID NOT IN TASKS"
|
||
TaskInFo=GetTaskInFo(TaskUUID)
|
||
TaskAnswerInFo=None
|
||
TaskEndTime = TaskInFo["TaskEndTime"]
|
||
TaskAnswerList=-1
|
||
if (int(TaskEndTime.timestamp()) - time.time()) <= 0: ReLoad=0
|
||
else: ReLoad=1
|
||
if Is_UserInTask(TaskUUID, GetELTUserUUID()):
|
||
TaskAnswerInFo=GetTaskAnswerInFo(TaskUUID, GetELTUserUUID())
|
||
if GetTaskUserInFo(TaskUUID, GetELTUserUUID())["UserDo"] == 1:
|
||
if flask.request.args.get("detailed"): TaskDo=3
|
||
else: return flask.redirect(f"/Tasks/TaskFinish.html?TaskUUID={TaskUUID}&TaskName={TaskInFo["TaskName"]}")
|
||
else:
|
||
TaskDo=1
|
||
TaskAnswerList=TaskInFo["TaskAnswer"]
|
||
else:
|
||
if GetTaskAlowDev(TaskUUID, GetELTUserUUID()): TaskDo=0
|
||
else: flask.abort(503)
|
||
return flask.render_template("/Manage/Tasks/TaskToDo.html",
|
||
TaskName=TaskInFo["TaskName"],
|
||
TaskPublisher=GetUUIDUser(GetBytesto16(TaskInFo["TaskPublisher"])),
|
||
TaskUUID=TaskUUID,
|
||
TaskStartTime=TaskInFo["TaskStartTime"],
|
||
TaskEndTime=TaskInFo["TaskEndTime"],
|
||
TaskAddTime=i18n.AdminMode if not TaskAnswerInFo else (i18n.NoTime if not TaskAnswerInFo["TaskAddTime"] else TaskAnswerInFo["TaskAddTime"].strftime("%Y-%m-%d %H:%M:%S")),
|
||
TaskFinishTime=i18n.AdminMode if not TaskAnswerInFo else (i18n.NoTime if not TaskAnswerInFo["TaskFinishTime"] else TaskAnswerInFo["TaskFinishTime"].strftime("%Y-%m-%d %H:%M:%S")),
|
||
TaskCCGOID=TaskInFo["TaskCCGOID"],
|
||
TaskNeed=TaskInFo["TaskNeed"].replace(r"\n","<br>"),
|
||
TaskOther=TaskInFo["TaskOther"].replace(r"\n","<br>"),
|
||
CountYear=TaskEndTime.year,
|
||
CountMonth=TaskEndTime.month,
|
||
CountDay=TaskEndTime.day,
|
||
CountHour=TaskEndTime.hour,
|
||
CountMinute=TaskEndTime.minute,
|
||
CountSecond=TaskEndTime.second,
|
||
ReLoad=ReLoad,
|
||
TaskDo=TaskDo,
|
||
TaskAnswerList=TaskAnswerList,
|
||
TaskType=LISTTOTASKTYPE(TaskInFo["TaskType"]),
|
||
TaskAnswer=LISTTOTASKANSWER(TaskInFo["TaskAnswer"]))
|
||
|
||
|
||
@Manage.route("/API/UserTaskSubmit.api", methods=["POST"])
|
||
@PreRequirements(1.0)
|
||
def UserTaskSubmit():
|
||
TaskUUID=flask.request.form.get("TaskUUID")
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
if not UserUUID: UserUUID = GetELTUserUUID()
|
||
File=flask.request.files.get("File")
|
||
LongInFo=flask.request.form.get("LongInFo")
|
||
ShortInFo=flask.request.form.get("ShortInFo")
|
||
LinkInFo=flask.request.form.get("LinkInFo")
|
||
if not Is_UUID(TaskUUID): return {"code":1,"msg":i18n.NoUUID("TaskUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_Task(TaskUUID): return i18n.NoTask(TaskUUID)
|
||
if not Is_UserInTask(TaskUUID, UserUUID): return {"code":1,"msg":i18n.ThisTaskNotBelongToYou}
|
||
TaskInFo=GetTaskInFo(TaskUUID)
|
||
if GetTaskUserInFo(TaskUUID, UserUUID)["UserDo"] == 1: return {"code":1,"msg":i18n.YouVeSubmitted}
|
||
if not TaskInFo["TaskEndTime"].timestamp() >= time.time(): return {"code":1,"msg":i18n.TaskTimeOut}
|
||
UserAnswer={"UserUpLoadFileName":"","UserUpLoadFile":"","UserLong":"","UserShort":"","UserDo":0,"UserPass":0,"TaskFinishTime":TimeFormatStr("%Y-%m-%d %H:%M:%S")}
|
||
#File ReName is System for it 's UUID
|
||
for i in TaskInFo["TaskAnswer"]:
|
||
if i == 1:
|
||
#if not File.content_length >= 1024*1024*1024:
|
||
# return f"文件或过小过大，无法上传，请重新打开页面后重试，File.content_length: {File.content_length}"
|
||
UserAnswer["UserUpLoadFileName"]=File.filename
|
||
UserAnswer["UserUpLoadFile"]=NSQL.Func.insertbytes(File.stream.read())
|
||
if i == 2:
|
||
UserAnswer["UserLong"]=LongInFo
|
||
if i == 3:
|
||
UserAnswer["UserShort"]=ShortInFo
|
||
if i == 4:
|
||
UserAnswer["UserLink"]=LinkInFo
|
||
UserAnswer["UserDo"]=1
|
||
SQLTasks.update(**UserAnswer,
|
||
WHERE=("TaskUUID=%s AND UserUUID=%s", (Get16toBytes(TaskUUID), Get16toBytes(UserUUID))),
|
||
FROM="Answer"
|
||
)
|
||
resp = flask.redirect(f"/Tasks/TaskFinish.html?TaskUUID={TaskUUID}")
|
||
return resp
|
||
|
||
|
||
@Manage.route("/API/TaskUpload.api", methods=["POST"])
|
||
@PreRequirements(2.0)
|
||
def UserUpTask():
|
||
TaskName=flask.request.form.get("TaskName")
|
||
TaskEndTime=flask.request.form.get("TaskEndTime")
|
||
TaskCCGOID=flask.request.form.get("TaskCCGOID")
|
||
TaskNeed=flask.request.form.get("TaskNeed")
|
||
TaskManual=flask.request.form.get("TaskManual")
|
||
TaskShop=flask.request.form.get("TaskShop")
|
||
TaskOther=flask.request.form.get("TaskOther")
|
||
try:time.mktime(time.strptime(TaskEndTime, "%Y-%m-%d %H:%M:%S"))
|
||
except:return {"code": 1, "msg": i18n.TimeAbnormal}
|
||
#if (int(TaskEndTime) - time.time()) < 7200:
|
||
# return {"code":1,"msg":i18n.TimeBeMostOver2Hour}
|
||
TaskType=[]
|
||
TaskAnswer=[]
|
||
for i in range(1,20+1):
|
||
if flask.request.form.get(f"TaskType[{i}]") != None:
|
||
TaskType.append(i)
|
||
for i in range(1,5+1):
|
||
if flask.request.form.get(f"TaskAnswer[{i}]") != None:
|
||
TaskAnswer.append(i)
|
||
SQLTasks.insert("Tasks",
|
||
TaskUUID=Get16toBytes(NewUUID()),
|
||
TaskName=TaskName,
|
||
TaskPublisher=Get16toBytes(GetELTUserUUID()),
|
||
TaskStartTime=TimeFormatStr("%Y-%m-%d %H:%M:%S"),
|
||
TaskEndTime=TaskEndTime,
|
||
TaskType="%s" % TaskType,
|
||
TaskAnswer="%s" % TaskAnswer,
|
||
TaskCCGOID=TaskCCGOID,
|
||
TaskNeed=TaskNeed,
|
||
TaskOther=TaskOther,
|
||
TaskManual=bool(TaskManual),
|
||
TaskShop=bool(TaskShop),
|
||
)
|
||
return {"code": 0}
|
||
|
||
|
||
@Manage.route("/API/UserTaskAdd.api", methods=["POST"])
|
||
@PreRequirements(1.0)
|
||
def UserAddTask():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
TaskUUID=flask.request.form.get("TaskUUID")
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not TaskUUID: return {"code":1,"msg":i18n.NoParameter("TaskUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_UUID(TaskUUID): return {"code":1,"msg":i18n.NoUUID("TaskUUID")}
|
||
if not Is_Task(TaskUUID): return {"code":1,"msg":i18n.NoTask(TaskUUID)}
|
||
if not GetTaskAlowDev(TaskUUID, GetELTUserUUID()): return {"code":1,"msg":i18n.YouDontHavePermissionToperate}
|
||
if Is_UserInTask(TaskUUID, UserUUID): return {"code":1,"msg":i18n.TaskAlreadyExist}
|
||
SQLTasks.insert("Answer",
|
||
UserUUID=Get16toBytes(UserUUID),
|
||
TaskUUID=Get16toBytes(TaskUUID),
|
||
TaskAddTime=TimeFormatStr("%Y-%m-%d %H:%M:%S"),
|
||
UserDo=0,
|
||
UserPass=0
|
||
)
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/GetMakeTasks.api")
|
||
@PreRequirements(1.0)
|
||
def UserGetMakeTasks():
|
||
ELTUserUUID=GetELTUserUUID()
|
||
UserUUID=flask.request.args.get("UserUUID", ELTUserUUID)
|
||
TasksReturn=[]
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not SubIsInOrIs(ELTUserUUID, UserUUID): return {"code":1,"count":1000,"data":i18n.YouDontHavaPermissionToSeeit}
|
||
for i in GetTasksByOne(GetELTUserUUID()):
|
||
TasksReturn.append(
|
||
{"TaskUUID":GetBytesto16(i["TaskUUID"]),
|
||
"TaskPublisher":GetBytesto16(i["TaskPublisher"]),
|
||
"TaskName":i["TaskName"],
|
||
"TaskEndTime":i["TaskEndTime"].strftime("%Y-%m-%d %H:%M:%S"),
|
||
"TaskType":LISTTOTASKTYPE(i["TaskType"]),
|
||
"TaskAnswer":LISTTOTASKANSWER(i["TaskAnswer"]),
|
||
"TaskCCGOID":i["TaskCCGOID"],
|
||
"TaskNeed":i["TaskNeed"],
|
||
"TaskOther":i["TaskOther"],
|
||
"TaskManual":i18n.Yes if i["TaskManual"] else i18n.No,
|
||
"TaskShop":i18n.Yes if i["TaskShop"] else i18n.No})
|
||
return {"code":0,"count":1000,"data":TasksReturn}
|
||
|
||
@Manage.route("/API/GetTasks.api")
|
||
@PreRequirements(1.0)
|
||
def UserGetTasks():
|
||
ELTUserUUID=GetELTUserUUID()
|
||
UserUUID=flask.request.args.get("UserUUID", ELTUserUUID)
|
||
TaskMod =flask.request.args.get("TaskMod", "0")
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if TaskMod not in ["1", 0]: return {"code":1,"msg":i18n.ModeError}
|
||
if not SubIsInOrIs(GetELTUserUUID(), UserUUID): return {"code":1,"count":1000,"data":i18n.YouDontHavaPermissionToSeeit}
|
||
TasksReturn=[]
|
||
for i in GetTasksNeedDo(UserUUID):
|
||
TaskUUID=GetBytesto16(i["TaskUUID"])
|
||
TaskInFo=GetTaskInFo(TaskUUID)
|
||
TaskAnswerInFo=GetTaskAnswerInFo(TaskUUID, UserUUID)
|
||
if i["UserDo"] != (0 if TaskMod == "0" else 1): continue
|
||
TasksReturn.append({"TaskUUID": TaskUUID,
|
||
"TaskPublisher": GetUUIDUser(GetBytesto16(TaskInFo["TaskPublisher"])),
|
||
"TaskName": TaskInFo["TaskName"],
|
||
"TaskDo": i["UserDo"],
|
||
"TaskPass": i["UserPass"],
|
||
"TaskStartTime": TaskInFo["TaskStartTime"].strftime("%Y-%m-%d %H:%M:%S"),
|
||
"TaskEndTime": TaskInFo["TaskEndTime"].strftime("%Y-%m-%d %H:%M:%S"),
|
||
"TaskAddTime": "未完成" if not TaskAnswerInFo["TaskAddTime"] else TaskAnswerInFo["TaskAddTime"].strftime("%Y-%m-%d %H:%M:%S"),
|
||
"TaskFinishTime": "未完成" if not TaskAnswerInFo["TaskFinishTime"] else TaskAnswerInFo["TaskFinishTime"].strftime("%Y-%m-%d %H:%M:%S"),
|
||
"TaskType": LISTTOTASKTYPE(TaskInFo["TaskType"]),
|
||
"TaskAnswer": LISTTOTASKANSWER(TaskInFo["TaskAnswer"]),
|
||
"TaskCCGOID": TaskInFo["TaskCCGOID"]})
|
||
return {"code":0,"count":1000,"data":TasksReturn}
|
||
|
||
@Manage.route("/API/GetTasksDevReceiver.api")
|
||
@PreRequirements(1.0)
|
||
def UserGetTasksDevReceiver():
|
||
TaskUUID=flask.request.args.get("TaskUUID")
|
||
if not TaskUUID: return {"code":0,"count":1000,"data":i18n.NoParameter("TaskUUID")}
|
||
if not Is_UUID(TaskUUID): return {"code":1,"msg":i18n.NoUUID("TaskUUID")}
|
||
if not Is_Task(TaskUUID): return {"code":1,"msg":i18n.NoTask(TaskUUID)}
|
||
TaskInFo=GetTaskInFo(TaskUUID)
|
||
TaskPublisher=GetBytesto16(TaskInFo["TaskPublisher"])
|
||
if not GetELTUserUUID() == TaskPublisher and not SubIsIn(GetELTUserUUID(), TaskPublisher): return {"code":0,"count":1000,"data":i18n.YouDontHavePermissionToperate}
|
||
if not GetTaskAlowDev(TaskUUID, GetELTUserUUID()): return {"code":1,"msg":i18n.YouDontHavePermissionToperate}
|
||
s=[]
|
||
for i in GetTaskUsers(TaskUUID):
|
||
s.append(
|
||
{"ReceiverUUID": GetBytesto16(i["UserUUID"]),
|
||
"ReceiverName": GetUUIDUser(GetBytesto16(i["UserUUID"])),
|
||
"ReceiverFinishFlan": i["UserDo"],
|
||
"PublisherFinishFlan": i["UserPass"],
|
||
"ReceiverFile": i["UserUpLoadFileName"]
|
||
})
|
||
return {"code":0,"count":1000,"data":s}
|
||
|
||
|
||
@Manage.route("/API/TasksDevPass.api", methods=["POST"])
|
||
@PreRequirements(1.0)
|
||
def UserTasksDevPass():
|
||
TaskUUID=flask.request.form.get("TaskUUID")
|
||
PassMod=flask.request.form.get("PassMod")
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
if not TaskUUID: return {"code":1,"msg":i18n.NoParameter("TaskUUID")}
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Is_UUID(TaskUUID): return {"code":1,"msg":i18n.NoUUID("TaskUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_Task(TaskUUID): return {"code":1,"msg":i18n.NoTask(TaskUUID)}
|
||
if not Is_User(UserUUID): return {"code":1,"msg":i18n.NoUser(UserUUID)}
|
||
if PassMod not in ["1", "0", "-1"]: return {"code":1,"msg":i18n.ModeError}
|
||
if not GetTaskAlowDev(TaskUUID, GetELTUserUUID()): return {"code":1,"msg":i18n.YouDontHavaPermissionToSeeit}
|
||
SQLTasks.update(UserPass=int(PassMod), WHERE=("TaskUUID=%s AND UserUUID=%s", (Get16toBytes(TaskUUID), Get16toBytes(UserUUID))), FROM="Answer")
|
||
return {"code":0,"msg":i18n.OperateSuccess}
|
||
|
||
@Manage.route("/API/UserTasksDelete.api", methods=["POST"])
|
||
@PreRequirements(1.0)
|
||
def UserGroupTasksDelete():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
TaskUUID=flask.request.form.get("TaskUUID")
|
||
PassMod=flask.request.form.get("PassMod")
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not TaskUUID: return {"code":1,"msg":i18n.NoParameter("TaskUUID")}
|
||
if not Is_UUID(TaskUUID): return {"code":1,"msg":i18n.NoUUID("TaskUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_Task(TaskUUID): return {"code":1,"msg":i18n.NoTask(TaskUUID)}
|
||
if not Is_User(UserUUID): return {"code":1,"msg":i18n.NoUser(UserUUID)}
|
||
if PassMod not in ["Task", "TaskFinish"]: return {"code":1,"msg":i18n.ModeError}
|
||
PassMod="0" if PassMod == "Task" else "1"
|
||
if not Is_Task(TaskUUID): return {"code":1,"msg":i18n.NoTask(TaskUUID)}
|
||
if not GetTaskAlowDev(TaskUUID, GetELTUserUUID()): return {"code":1,"msg":i18n.YouDontHavePermissionToperate}
|
||
if not SQLTasks.istrue("Answer", WHERE=("TaskUUID=%s AND UserUUID=%s AND UserDo=%s", (Get16toBytes(TaskUUID), Get16toBytes(UserUUID), PassMod))): return {"code":1,"msg":i18n.NoAnswer(TaskUUID)}
|
||
SQLTasks.delete("Answer", WHERE=("TaskUUID=%s AND UserUUID=%s AND UserDo=%s", (Get16toBytes(TaskUUID), Get16toBytes(UserUUID), PassMod)))
|
||
return {"code":0,"msg":i18n.OperateSuccess}
|
||
|
||
|
||
@Manage.route("/API/TasksDelete.api", methods=["POST"])
|
||
@PreRequirements(1.0)
|
||
def UserTasksDelete():
|
||
TaskUUID=flask.request.form.get("TaskUUID")
|
||
ELTUserUUID=GetELTUserUUID()
|
||
if not TaskUUID: return {"code":1,"data":i18n.NoParameter("TaskUUID")}
|
||
if not Is_UUID(TaskUUID): return {"code":1,"data":i18n.NoUUID("TaskUUID")}
|
||
if not Is_Task(TaskUUID): return {"code":1,"data":i18n.NoTask(TaskUUID)}
|
||
if not GetTaskAlowDev(TaskUUID, ELTUserUUID): return {"code":1,"msg":i18n.YouDontHavePermissionToperate}
|
||
SQLTasks.delete("Tasks", WHERE=("TaskUUID=%s", Get16toBytes(TaskUUID)))
|
||
SQLTasks.delete("Answer", WHERE=("TaskUUID=%s", Get16toBytes(TaskUUID)))
|
||
return {"code":0,"msg":i18n.OperateSuccess}
|
||
|
||
|
||
@Manage.route("/API/TalentPlanSubCard.api")
|
||
@PreRequirements(4.0)
|
||
def TalentPlanSubCardAPI():
|
||
UserUUID=str(flask.request.args.get("UserUUID"))
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
_=SQLPlans.selectashead(NSQL.MOD.ALL, FROM="TalentPlan", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)), _limit=1)
|
||
if not _: return {"code":1,"msg":i18n.GetError}
|
||
_=_[0]
|
||
return {"UserName": _["UserName"],
|
||
"UserUUID": UserUUID,
|
||
"UserEcho": _["UserEcho"],
|
||
"Other": _["Other"],
|
||
"UserWork": _["UserWork"],
|
||
"UserWillWork": _["UserWillWork"],
|
||
"UserBornTime": str(_["UserBornTime"]),
|
||
"UserIDCard": _["UserIDCard"],
|
||
"UserBilibili": _["UserBilibili"],
|
||
"UserTikTok": _["UserTikTok"],
|
||
"UserTel": _["UserTel"],
|
||
"UserKuaiShou": _["UserKuaiShou"],
|
||
"UserWX": _["UserWX"]}
|
||
|
||
@Manage.route("/API/TalentPlan.api")
|
||
@PreRequirements(4.0)
|
||
def UserTalentPlanApi():
|
||
Label=[]
|
||
for i in SQLPlans.selectashead(NSQL.MOD.ALL, FROM="TalentPlan"):
|
||
i["UserUUID"]=GetBytesto16(i["UserUUID"])
|
||
i["UserWork"]=HightLight(i["UserWork"])
|
||
i["UserWillWork"]=HightLight(i["UserWillWork"])
|
||
Label.append(i)
|
||
return {"code":0,"count":1000,"data":Label}
|
||
|
||
@Manage.route("/API/TalentPlanEcho.api")
|
||
def UserTalentPlanEchoApi():
|
||
Label=[]
|
||
for i in SQLPlans.selectashead(NSQL.MOD.ALL, FROM="TalentPlan"):
|
||
if i["UserEcho"] == "on":
|
||
i["UserUUID"]=GetBytesto16(i["UserUUID"])
|
||
i["UserBornTime"]="xxx"
|
||
i["UserIDCard"]="xxx"
|
||
i["UserWX"]="xxx"
|
||
i["UserTel"]="xxx"
|
||
i["UserWork"]=HightLight(i["UserWork"])
|
||
i["UserWillWork"]=HightLight(i["UserWillWork"])
|
||
Label.append(i)
|
||
return {"code":0,"count":1000,"data":Label}
|
||
|
||
@Manage.route("/API/TalentPlanUpSub.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserTalentPlanUpSub():
|
||
_=flask.request.form.to_dict()
|
||
try:time.mktime(time.strptime(_["UserBornTime"], "%Y-%m-%d %H:%M:%S"))
|
||
except:return {"code":1,"msg":i18n.TimeAbnormal}
|
||
if not isinstance(ast.literal_eval(_["UserWork"]), list): return {"code":1,"msg":i18n.DataError("UserWork", "List")}
|
||
if not isinstance(ast.literal_eval(_["UserWillWork"]), list): return {"code":1,"msg":i18n.DataError("UserWillWork", "List")}
|
||
SQLPlans.insert("TalentPlan",
|
||
UserName=_["UserName"],
|
||
UserUUID=Get16toBytes(NewUUID()),
|
||
UserEcho=_["UserEcho"],
|
||
UserWork=_["UserWork"],
|
||
UserWillWork=_["UserWillWork"],
|
||
UserBornTime=_["UserBornTime"],
|
||
UserIDCard=_["UserIDCard"],
|
||
UserBilibili=_["UserBilibili"],
|
||
UserTikTok=_["UserTikTok"],
|
||
UserKuaiShou=_["UserKuaiShou"],
|
||
UserTel=_["UserTel"],
|
||
UserWX=_["UserWX"],
|
||
Other=_["Other"])
|
||
return {"code":0,"msg":i18n.OperateSuccess}
|
||
|
||
@Manage.route("/API/TalentPlanDelSub.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserTalentPlanDelSub():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_User(UserUUID): return {"code":1,"msg":i18n.NoUser(UserUUID)}
|
||
if SQLPlans.istrue("TalentPlan", WHERE=("UserUUID=%s", Get16toBytes(UserUUID))):
|
||
SQLPlans.delete("TalentPlan", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)))
|
||
return {"code":0,"msg":i18n.OperateSuccess}
|
||
else:
|
||
return {"code":0,"msg":i18n.OperateError}
|
||
|
||
|
||
|
||
|
||
|
||
@Manage.route("/API/GetArchives.api")
|
||
@PreRequirements(2.0)
|
||
def UserGetArchives():
|
||
UserUUID=flask.request.args.get("UserUUID", GetELTUserUUID())
|
||
if not UserUUID: return {"code":1,"count":1000,"data":i18n.NoParameter("UserUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":0,"count":1000,"data":i18n.NoUUID("UserUUID")}
|
||
if not Is_User(UserUUID): return {"code":0,"count":1000,"data":i18n.NoUser(UserUUID)}
|
||
if not SubIsInOrIs(GetELTUserUUID(), UserUUID): return {"code":0,"count":1000,"data":i18n.NoPermission}
|
||
if not (Archives:=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="archives", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)))): return {"code":0,"count":1000,"data":[]}
|
||
_=[]
|
||
for i in Archives:
|
||
i["UserUUID"]=GetBytesto16(i["UserUUID"])
|
||
i["ArchivesUUID"]=GetBytesto16(i["ArchivesUUID"])
|
||
i["ArchivesID"]=GetBytesto16(i["ArchivesID"])
|
||
i["ArchivesAuthorUUID"]=GetBytesto16(i["ArchivesAuthorUUID"])
|
||
if Is_User(i["ArchivesAuthorUUID"]):
|
||
i["ArchivesAuthorName"]=ReadUserConfig(i["ArchivesAuthorUUID"])["UserName"]
|
||
i["ArchivesCreateTime"]=i["ArchivesCreateTime"].strftime("%Y-%m-%d %H:%M:%S")
|
||
i["ArchivesTextName"]=""
|
||
i["ArchivesTextDesc"]=""
|
||
if (ArchivesText:=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="archivestext", WHERE=("ArchivesID=%s", Get16toBytes(i["ArchivesID"])), _limit=1)):
|
||
i["ArchivesTextName"]=ArchivesText[0]["ArchivesName"]
|
||
i["ArchivesTextDesc"]=ArchivesText[0]["ArchivesDesc"]
|
||
_.append(i)
|
||
return {"code":0,"count":1000,"data":_}
|
||
|
||
@Manage.route("/API/GetArchivesText.api")
|
||
@PreRequirements(4.0)
|
||
def UserGetArchivesText():
|
||
if not (ArchivesText:=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="archivestext", WHERE="1=1")): return {"code":0,"count":1000,"data":[]}
|
||
_=[]
|
||
for i in ArchivesText:
|
||
i["ArchivesID"]=GetBytesto16(i["ArchivesID"])
|
||
_.append(i)
|
||
return {"code":0,"count":1000,"data":_}
|
||
|
||
@Manage.route("/API/AddArchivesText.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserAddArchivesText():
|
||
ArchivesName=flask.request.form.get("ArchivesName")
|
||
ArchivesDesc=flask.request.form.get("ArchivesDesc")
|
||
ArchivesID=flask.request.form.get("ArchivesID", GUUID())
|
||
if not ArchivesName: return {"code":1,"msg":i18n.NoParameter("ArchivesName")}
|
||
if not ArchivesDesc: return {"code":1,"msg":i18n.NoParameter("ArchivesDesc")}
|
||
if not Is_UUID(ArchivesID): {"code":1,"msg":i18n.NoUUID("ArchivesID")}
|
||
if len(ArchivesName) > 1024 or len(ArchivesDesc) > 1024*1024: return {"code":1,"msg":i18n.TooBig}
|
||
if SQLUsers.istrue("archivestext", WHERE=("ArchivesID=%s", Get16toBytes(ArchivesID))):
|
||
SQLUsers.update(FROM="archivestext", WHERE=("ArchivesID=%s", Get16toBytes(ArchivesID)), ArchivesName=ArchivesName, ArchivesDesc=ArchivesDesc)
|
||
else:
|
||
SQLUsers.insert("archivestext", ArchivesName=ArchivesName, ArchivesDesc=ArchivesDesc, ArchivesID=Get16toBytes(ArchivesID))
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/DelArchivesText.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserDelArchivesText():
|
||
ArchivesID=flask.request.form.get("ArchivesID")
|
||
if not ArchivesID: {"code":1,"msg":i18n.NoParameter("ArchivesID")}
|
||
if not Is_UUID(ArchivesID): return {"code":1,"msg":i18n.NoUUID("ArchivesID")}
|
||
if not SQLUsers.istrue("archivestext", WHERE=("ArchivesID=%s", Get16toBytes(ArchivesID))): return {"code":1,"msg":i18n.NoFound("ArchivesID")}
|
||
SQLUsers.delete(FROM="archivestext", WHERE=("ArchivesID=%s", Get16toBytes(ArchivesID)))
|
||
return {"code":0,"msg":i18n.DelSuccess}
|
||
|
||
@Manage.route("/API/AddArchives.api", methods=["POST"])
|
||
@PreRequirements(2.0)
|
||
def UserAddArchives():
|
||
ArchivesUUID=flask.request.form.get("ArchivesUUID", GUUID())
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
ArchivesName=flask.request.form.get("ArchivesName")
|
||
ArchivesDesc=flask.request.form.get("ArchivesDesc")
|
||
ArchivesPoints=flask.request.form.get("ArchivesPoints")
|
||
ArchivesID=flask.request.form.get("ArchivesID", "0"*16)
|
||
ArchivesAuthorUUID=GetELTUserUUID()
|
||
ArchivesCreateTime=TimeFormatInt()
|
||
try: ArchivesPoints=int(ArchivesPoints)
|
||
except: return {"code":1,"msg":i18n.DataError("ArchivesPoints", "Int")}
|
||
if not ArchivesUUID: return {"code":1,"msg":i18n.NoParameter("ArchivesUUID")}
|
||
if not ArchivesID: return {"code":1,"msg":i18n.NoParameter("ArchivesID")}
|
||
if not ArchivesName: return {"code":1,"msg":i18n.NoParameter("ArchivesName")}
|
||
if not ArchivesDesc: return {"code":1,"msg":i18n.NoParameter("ArchivesDesc")}
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if len(ArchivesName) > 1024 or len(ArchivesDesc) > 1024*1024: return {"code":1,"msg":i18n.No}
|
||
if not SubIsIn(GetELTUserUUID(), UserUUID): return {"code":1,"count":1000,"data":i18n.NoIn("ELTUserUUID", "UserUUID")}
|
||
if not Is_UUID(ArchivesUUID): {"code":1,"msg":i18n.NoUUID("ArchivesUUID")}
|
||
if not Is_UUID(ArchivesID): {"code":1,"msg":i18n.NoUUID("ArchivesID")}
|
||
if not SQLUsers.istrue("archivestext", WHERE=("ArchivesID=%s", Get16toBytes(ArchivesID))): return {"code":1,"msg":i18n.NoFound("ArchivesID")}
|
||
if SQLUsers.istrue("archives", WHERE=("ArchivesUUID=%s", Get16toBytes(ArchivesUUID))):
|
||
SQLUsers.update(FROM="archives", WHERE=("ArchivesUUID=%s", Get16toBytes(ArchivesUUID)),
|
||
ArchivesID=Get16toBytes(ArchivesID), ArchivesName=ArchivesName, ArchivesDesc=ArchivesDesc, ArchivesPoints=ArchivesPoints,
|
||
ArchivesAuthorUUID=Get16toBytes(ArchivesAuthorUUID))
|
||
else:
|
||
SQLUsers.insert("archives", UserUUID=Get16toBytes(UserUUID),
|
||
ArchivesUUID=Get16toBytes(ArchivesUUID), ArchivesID=Get16toBytes(ArchivesID), ArchivesName=ArchivesName, ArchivesDesc=ArchivesDesc, ArchivesPoints=ArchivesPoints,
|
||
ArchivesAuthorUUID=Get16toBytes(ArchivesAuthorUUID), ArchivesCreateTime=ArchivesCreateTime)
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/DelArchives.api", methods=["POST"])
|
||
@PreRequirements(2.0)
|
||
def UserDelArchives():
|
||
ArchivesUUID=flask.request.form.get("ArchivesUUID")
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
if not ArchivesUUID: {"code":1,"msg":i18n.NoParameter("ArchivesUUID")}
|
||
if not UserUUID: {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Is_UUID(ArchivesUUID): {"code":1,"msg":i18n.NoUUID("ArchivesUUID")}
|
||
if not Is_UUID(UserUUID): {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_User(UserUUID): {"code":1,"msg":i18n.NoFound("UserUUID")}
|
||
if not SubIsIn(GetELTUserUUID(), UserUUID): return {"code":0,"count":1000,"data":i18n.NoIn("ELTUserUUID", "UserUUID")}
|
||
if SQLUsers.istrue("archives", WHERE=("ArchivesUUID=%s", Get16toBytes(ArchivesUUID))):
|
||
SQLUsers.delete(FROM="archives", WHERE=("ArchivesUUID=%s", Get16toBytes(ArchivesUUID)))
|
||
return {"code":0,"msg":"success"}
|
||
|
||
|
||
def process_checkin_data(checkin_records, week_start_date):
|
||
week_status = [0] * 7
|
||
if not checkin_records:
|
||
return week_status
|
||
try:
|
||
if isinstance(week_start_date, datetime.datetime):
|
||
start_date = week_start_date.date()
|
||
else:
|
||
date_str = str(week_start_date).split()[0]
|
||
year, month, day = map(int, date_str.split('-'))
|
||
start_date = datetime.datetime(year, month, day).date()
|
||
except:
|
||
return week_status
|
||
week_dates = [start_date + datetime.timedelta(days=i) for i in range(7)]
|
||
for record in checkin_records:
|
||
if not record or 'CheckInTime' not in record:
|
||
continue
|
||
try:
|
||
checkin_time = record['CheckInTime']
|
||
checkin_date = checkin_time.date()
|
||
if start_date <= checkin_date <= week_dates[-1]:
|
||
day_of_week = (checkin_date - start_date).days
|
||
if 0 <= day_of_week < 7:
|
||
week_status[day_of_week] = 1
|
||
except:
|
||
continue
|
||
return week_status
|
||
|
||
def days_between_today(target_date_str):
|
||
try:
|
||
today = datetime.datetime.now().date()
|
||
target_date = datetime.datetime.strptime(target_date_str, "%Y-%m-%d").date()
|
||
delta = abs((target_date - today).days)
|
||
return delta + 1
|
||
except ValueError:
|
||
return None
|
||
|
||
@Manage.route("/API/AssessmentScore.api")
|
||
@PreRequirements(2.0)
|
||
def UserAssessmentScore():
|
||
ELTUserUUID=GetELTUserUUID()
|
||
UserUUID=flask.request.args.get("UserUUID", ELTUserUUID)
|
||
if not SubIsInOrIs(ELTUserUUID, UserUUID) and GetPermissions(ELTUserUUID) < 4: return {"code":1,"msg":i18n.NoIn("ELTUserUUID", "UserUUID")}
|
||
CheckIn3=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="checkin", WHERE=("UserUUID=%s AND WeekFirstTime=%s", (Get16toBytes(UserUUID), GetWeekStartDate(week_seek=-2))), _limit=7)
|
||
CheckIn2=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="checkin", WHERE=("UserUUID=%s AND WeekFirstTime=%s", (Get16toBytes(UserUUID), GetWeekStartDate(week_seek=-1))), _limit=7)
|
||
CheckIn1=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="checkin", WHERE=("UserUUID=%s AND WeekFirstTime=%s", (Get16toBytes(UserUUID), GetWeekStartDate(week_seek=0))), _limit=7)
|
||
Archives=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="archives", WHERE=("UserUUID=%s AND ArchivesPoints!=0", Get16toBytes(UserUUID)))
|
||
last_week_data = process_checkin_data(CheckIn3, GetWeekStartDate(week_seek=-2))
|
||
current_week_data = process_checkin_data(CheckIn2, GetWeekStartDate(week_seek=-1))
|
||
next_week_data = process_checkin_data(CheckIn1, GetWeekStartDate(week_seek=0))
|
||
penaltyItems=[]
|
||
AMScore=100
|
||
bonusItems=[{"description": i18n.InitialAssessmentScore, "points": 100}]
|
||
last_week_minus_score = 5 if len(CheckIn3) < 3 else 0
|
||
current_week_minus_score = 5 if len(CheckIn2) < 3 else 0
|
||
AMScore -= last_week_minus_score
|
||
AMScore -= current_week_minus_score
|
||
if last_week_minus_score: penaltyItems.append({"description": i18n.LWSIAWU, "points": 5})
|
||
if current_week_minus_score: penaltyItems.append({"description": i18n.LWSAF, "points": 5})
|
||
for i in Archives:
|
||
_={"description": i["ArchivesName"], "points": i["ArchivesPoints"]}
|
||
AMScore+=i["ArchivesPoints"]
|
||
bonusItems.append(_) if i["ArchivesPoints"] > 0 else penaltyItems.append(_)
|
||
return {"success": True, "data": {
|
||
"score": AMScore if AMScore < 100 else 100,
|
||
"tscore": AMScore,
|
||
"attendance": {
|
||
"lastWeek": last_week_data,
|
||
"currentWeek": current_week_data,
|
||
"nextWeek": next_week_data,
|
||
},
|
||
"bonusItems": bonusItems,
|
||
"penaltyItems": penaltyItems
|
||
}}
|
||
|
||
@App.route("/API/GetWebSiteShowMembers.api")
|
||
@Manage.route("/API/GetWebSiteShowMembers.api")
|
||
def UserGetWebSiteShowMembersAPI():
|
||
Type=flask.request.args.get("Type")
|
||
if not Type: return {"code":1,"msg":i18n.NoParameter("Type")}
|
||
if Type not in ["Members", "AKS", "Collaborators"]: return {"code":1,"msg":i18n.ModeError}
|
||
_=SQLUsers.selectashead(NSQL.MOD.ALL, FROM=f"show_{Type.lower()}", WHERE="1=1")
|
||
_2=[]
|
||
for i in _:
|
||
i["UserUUID"]=GetBytesto16(i["UserUUID"])
|
||
UserConfig=ReadUserConfig(i["UserUUID"])
|
||
_2.append({
|
||
"UserUUID": i["UserUUID"],
|
||
"UserName": i["UserName"] if i["UserName"] else GetUUIDUser(i["UserUUID"]),
|
||
"UserBrInt": i["UserBrInt"] if i["UserBrInt"] else UserConfig["UserPersonalSignature"],
|
||
"UserPhotoPath": i["UserPhotoPath"] if i["UserPhotoPath"] else "https://ugm.gvsds.com/GetArgsUserHeadPng.api?UserUUID=%s" % i["UserUUID"],
|
||
"UserSoundPath": i["UserSoundPath"] if i["UserSoundPath"] else "",
|
||
"UserWork": "" if not i["UserWork"] else (UserConfig["UserJob"] if i["UserWork"] == "work" else i["UserWork"]),
|
||
"UserTel": "" if not i["UserTel"] else (RUserTele(GetBytesto16(UserConfig["UserTele"])) if i["UserTel"] == "tel" else i["UserTel"]),
|
||
"UserEmail": "" if not i["UserEmail"] else (UserConfig["UserEmail"] if i["UserEmail"] == "email" else i["UserEmail"]),
|
||
"UserQQName": "" if not i["UserQQName"] else i["UserQQName"],
|
||
"UserWXName": "" if not i["UserWXName"] else i["UserWXName"],
|
||
"UserQQ": "" if not i["UserQQ"] else (UserConfig["UserQQ"] if i["UserQQ"] == "qq" else i["UserQQ"]),
|
||
"UserWX": "" if not i["UserWX"] else (UserConfig["UserWX"] if i["UserWX"] == "wx" else i["UserWX"]),
|
||
"UserAccentColor": i["UserAccentColor"] if i["UserAccentColor"] else "#555"
|
||
})
|
||
return {"code":0,"count":1000,"data":_2}
|
||
|
||
@Manage.route("/API/WebSiteShowMembersDel.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserWebSiteShowMembersDelAPI():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
Type=flask.request.form.get("Type")
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Type: return {"code":1,"msg":i18n.NoParameter("Type")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_User(UserUUID): return {"code":1,"msg":i18n.NoUser(UserUUID)}
|
||
if Type not in ["Members", "AKS", "Collaborators"]: return {"code":1,"msg":i18n.ModeError}
|
||
if not SQLUsers.istrue(f"show_{Type.lower()}", WHERE=("UserUUID=%s", Get16toBytes(UserUUID))): return {"code":1,"msg":i18n.NoFound("UserUUID")}
|
||
SQLUsers.delete(f"show_{Type.lower()}", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)))
|
||
return {"code":0}
|
||
|
||
@Manage.route("/API/WebSiteShowMembersAdd.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserWebSiteShowMembersAddAPI():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
Type=flask.request.form.get("Type")
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Type: return {"code":1,"msg":i18n.NoParameter("Type")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_User(UserUUID): return {"code":1,"msg":i18n.NoUser(UserUUID)}
|
||
if Type not in ["Members", "AKS", "Collaborators"]: return {"code":1,"msg":i18n.ModeError}
|
||
if SQLUsers.istrue(f"show_{Type.lower()}", WHERE=("UserUUID=%s", Get16toBytes(flask.request.form.get("UserUUID")))): return {"code":1,"msg":i18n.AlreadyExist}
|
||
SQLUsers.insert(f"show_{Type.lower()}",
|
||
UserUUID=Get16toBytes(UserUUID),
|
||
UserName=flask.request.form.get("UserName") if flask.request.form.get("UserName") else "",
|
||
UserBrInt=flask.request.form.get("UserBrInt") if flask.request.form.get("UserBrInt") else ReadUserConfig(flask.request.form.get("UserUUID"), "UserPersonalSignature"),
|
||
UserPhotoPath=flask.request.form.get("UserPhotoPath") if flask.request.form.get("UserPhotoPath") else "",
|
||
UserSoundPath=flask.request.form.get("UserSoundPath") if flask.request.form.get("UserSoundPath") else "",
|
||
UserWork=flask.request.form.get("UserWork") if flask.request.form.get("UserWork") else "",
|
||
UserTel=flask.request.form.get("UserTel") if flask.request.form.get("UserTel") else "",
|
||
UserEmail=flask.request.form.get("UserEmail") if flask.request.form.get("UserEmail") else "",
|
||
UserQQName=flask.request.form.get("UserQQName") if flask.request.form.get("UserQQName") else "",
|
||
UserWXName=flask.request.form.get("UserWXName") if flask.request.form.get("UserWXName") else "",
|
||
UserQQ=flask.request.form.get("UserQQ") if flask.request.form.get("UserQQ") else "",
|
||
UserWX=flask.request.form.get("UserWX") if flask.request.form.get("UserWX") else "",
|
||
UserAccentColor=flask.request.form.get("UserAccentColor") if flask.request.form.get("UserAccentColor") else ""
|
||
)
|
||
return {"code":0}
|
||
|
||
|
||
@Manage.route("/API/GetIdCard.api")
|
||
@PreRequirements(4.0)
|
||
def UserGetIdCard():
|
||
if not (IdCards:=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="idcard", WHERE="1=1")): return {"code":0,"count":1000,"data":[]}
|
||
_=[]
|
||
for i in IdCards:
|
||
i["UserUUID"]=GetBytesto16(i["UserUUID"])
|
||
i["Born"]=i["Born"].strftime("%Y-%m-%d")
|
||
i["ChangeStudentStatus"]=json.dumps(i["ChangeStudentStatus"], ensure_ascii=False)
|
||
i["CorrespondenceAddress"]=json.dumps(i["CorrespondenceAddress"], ensure_ascii=False)
|
||
i["InformationAboutFamilyMembers"]=json.dumps(i["InformationAboutFamilyMembers"], ensure_ascii=False)
|
||
i["Appointments"]=json.dumps(i["Appointments"], ensure_ascii=False)
|
||
_.append(i)
|
||
return {"code":0,"count":1000,"data":_}
|
||
|
||
@Manage.route("/API/AddIdCard.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserAddIdCard():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
Name=flask.request.form.get("Name")
|
||
OldName=flask.request.form.get("OldName")
|
||
Born=flask.request.form.get("Born")
|
||
Sex=flask.request.form.get("Sex")
|
||
Ethnic=flask.request.form.get("Ethnic")
|
||
IdentificationNumber=flask.request.form.get("IdentificationNumber")
|
||
StudentRegistrationNumber=flask.request.form.get("StudentRegistrationNumber")
|
||
ChangeStudentStatus=flask.request.form.get("ChangeStudentStatus")
|
||
CorrespondenceAddress=flask.request.form.get("CorrespondenceAddress")
|
||
HeadImage=flask.request.form.get("HeadImage")
|
||
InformationAboutFamilyMembers=flask.request.form.get("InformationAboutFamilyMembers")
|
||
Appointments=flask.request.form.get("Appointments")
|
||
ReadmeReport=flask.request.form.get("ReadmeReport")
|
||
# ChangeStudentStatus #HeadImage #InformationAboutFamilyMembers #Appointments #ReadmeReport
|
||
if not UserUUID: return {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Name: return {"code":1,"msg":i18n.NoParameter("Name")}
|
||
if not OldName: OldName=""
|
||
if not Born: return {"code":1,"msg":i18n.NoParameter("Born")}
|
||
if not Sex: return {"code":1,"msg":i18n.NoParameter("Sex")}
|
||
if not Ethnic: return {"code":1,"msg":i18n.NoParameter("Ethnic")}
|
||
if not IdentificationNumber: return {"code":1,"msg":i18n.NoParameter("IdentificationNumber")}
|
||
if not StudentRegistrationNumber: return {"code":1,"msg":i18n.NoParameter("StudentRegistrationNumber")}
|
||
if not ChangeStudentStatus: ChangeStudentStatus="[]"
|
||
if not CorrespondenceAddress: CorrespondenceAddress="[]"
|
||
if not HeadImage: HeadImage=""
|
||
if not InformationAboutFamilyMembers: InformationAboutFamilyMembers="[]"
|
||
if not Appointments: Appointments="[]"
|
||
if not ReadmeReport: ReadmeReport=""
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not Is_User(UserUUID): return {"code":1,"msg":i18n.NoUser(UserUUID)}
|
||
if len(Name) > 128: return {"code":1,"msg":i18n.TooBigMsg("Name", "128B")}
|
||
if len(OldName) > 128: return {"code":1,"msg":i18n.TooBigMsg("OldName", "128B")}
|
||
try: time.mktime(time.strptime(Born, "%Y-%m-%d"))
|
||
except: return {"code": 1, "msg": i18n.TimeAbnormal}
|
||
if len(Sex) > 10: return {"code":1,"msg":i18n.TooBigMsg("Sex", "10B")}
|
||
if len(Ethnic) > 20: return {"code":1,"msg":i18n.TooBigMsg("Ethnic", "20B")}
|
||
if len(IdentificationNumber) > 20: return {"code":1,"msg":i18n.TooBigMsg("IdentificationNumber", "20B")}
|
||
try: int(IdentificationNumber)
|
||
except:return {"code":1,"msg":i18n.DataError("IdentificationNumber", "int")}
|
||
if len(StudentRegistrationNumber) > 30: return {"code":1,"msg":i18n.TooBigMsg("StudentRegistrationNumber", "30B")}
|
||
if len(ChangeStudentStatus) > 4096: return {"code":1,"msg":i18n.TooBigMsg("ChangeStudentStatus", "4096B")}
|
||
try: json.loads(ChangeStudentStatus)
|
||
except: return {"code":1,"msg":i18n.DataError("ChangeStudentStatus", "dict")}
|
||
if len(CorrespondenceAddress) > 4096: return {"code":1,"msg":i18n.TooBigMsg("CorrespondenceAddress", "4096B")}
|
||
try: json.loads(CorrespondenceAddress)
|
||
except: return {"code":1,"msg":i18n.DataError("CorrespondenceAddress", "list")}
|
||
if len(HeadImage) > 4096: return {"code":1,"msg":i18n.TooBigMsg("HeadImage", "4096B")}
|
||
if len(InformationAboutFamilyMembers) > 4096: return {"code":1,"msg":i18n.TooBigMsg("InformationAboutFamilyMembers", "4096B")}
|
||
try: json.loads(InformationAboutFamilyMembers)
|
||
except: return {"code":1,"msg":i18n.DataError("InformationAboutFamilyMembers", "dict")}
|
||
if len(Appointments) > 4096: return {"code":1,"msg":i18n.TooBigMsg("Appointments", "4096B")}
|
||
try: json.loads(Appointments)
|
||
except: return {"code":1,"msg":i18n.DataError("Appointments", "dict")}
|
||
if len(ReadmeReport) > 4096: return {"code":1,"msg":i18n.TooBigMsg("ReadmeReport", "4096B")}
|
||
if SQLUsers.istrue("idcard", WHERE=("UserUUID=%s", Get16toBytes(UserUUID))):
|
||
SQLUsers.update(FROM="idcard", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)),
|
||
Name=Name,
|
||
OldName=OldName,
|
||
Born=Born,
|
||
Sex=Sex,
|
||
Ethnic=Ethnic,
|
||
IdentificationNumber=IdentificationNumber,
|
||
StudentRegistrationNumber=StudentRegistrationNumber,
|
||
ChangeStudentStatus=ChangeStudentStatus,
|
||
CorrespondenceAddress=CorrespondenceAddress,
|
||
HeadImage=HeadImage,
|
||
InformationAboutFamilyMembers=InformationAboutFamilyMembers,
|
||
Appointments=Appointments,
|
||
ReadmeReport=ReadmeReport)
|
||
else:
|
||
SQLUsers.insert("idcard",
|
||
UserUUID=Get16toBytes(UserUUID),
|
||
Name=Name,
|
||
OldName=OldName,
|
||
Born=Born,
|
||
Sex=Sex,
|
||
Ethnic=Ethnic,
|
||
IdentificationNumber=IdentificationNumber,
|
||
StudentRegistrationNumber=StudentRegistrationNumber,
|
||
ChangeStudentStatus=ChangeStudentStatus,
|
||
CorrespondenceAddress=CorrespondenceAddress,
|
||
HeadImage=HeadImage,
|
||
InformationAboutFamilyMembers=InformationAboutFamilyMembers,
|
||
Appointments=Appointments,
|
||
ReadmeReport=ReadmeReport)
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/DelIdCard.api", methods=["POST"])
|
||
@PreRequirements(4.0)
|
||
def UserDelIdCard():
|
||
UserUUID=flask.request.form.get("UserUUID")
|
||
if not UserUUID: {"code":1,"msg":i18n.NoParameter("UserUUID")}
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not SQLUsers.istrue("idcard", WHERE=("UserUUID=%s", Get16toBytes(UserUUID))): return {"code":1,"msg":i18n.NoFound("UserUUID")}
|
||
SQLUsers.delete(FROM="idcard", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)))
|
||
return {"code":0,"msg":i18n.DelSuccess}
|
||
|
||
@Manage.route("/API/TIdCard.api")
|
||
def UserTIdCard():
|
||
UserUUID=flask.request.form.get("UserUUID", GetELTUserUUID())
|
||
if not Is_UUID(UserUUID): return {"code":1,"msg":i18n.NoUUID("UserUUID")}
|
||
if not SQLUsers.istrue("idcard", WHERE=("UserUUID=%s", Get16toBytes(UserUUID))): return {"code":1,"msg":i18n.NoFound("IdCardUserUUID")}
|
||
_=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="idcard", WHERE=("UserUUID=%s", Get16toBytes(UserUUID)), _limit=1)
|
||
if not _: return {"code":1,"msg":i18n.GetError}
|
||
_=_[0]
|
||
_["UserUUID"]=GetBytesto16(_["UserUUID"])
|
||
_["Born"]=_["Born"].strftime("%Y-%m-%d")
|
||
_["Year"]=_["Born"].split("-")[0]
|
||
_["Month"]=_["Born"].split("-")[1]
|
||
_["Day"]=_["Born"].split("-")[2]
|
||
_["ChangeStudentStatus"]=json.dumps(_["ChangeStudentStatus"], ensure_ascii=False)
|
||
_["CorrespondenceAddress"]=" ".join(_["CorrespondenceAddress"])
|
||
_["InformationAboutFamilyMembers"]=json.dumps(_["InformationAboutFamilyMembers"], ensure_ascii=False)
|
||
_["Appointments"]=json.dumps(_["Appointments"], ensure_ascii=False)
|
||
return {"code":0,"data":_}
|
||
|
||
|
||
|
||
|
||
|
||
@Manage.route("/API/Money.api")
|
||
@PreRequirements(1.0)
|
||
def UserGetMoney():
|
||
UserConfig = GetELTUserConfig()
|
||
UserMoneyIntegral = UserConfig["UserMoneyIntegral"]
|
||
UserMoneyLightCoin = UserConfig["UserMoneyLightCoin"]
|
||
UserMoneyBrightCoin = UserConfig["UserMoneyBrightCoin"]
|
||
UserMoneyDarkCoin = UserConfig["UserMoneyDarkCoin"]
|
||
return {"UserMoneyIntegral": UserMoneyIntegral,
|
||
"UserMoneyLightCoin": UserMoneyLightCoin,
|
||
"UserMoneyBrightCoin": UserMoneyBrightCoin,
|
||
"UserMoneyDarkCoin": UserMoneyDarkCoin}
|
||
|
||
|
||
|
||
|
||
PersonalForm=["PersonalPageName", "Subtitle", "BackgroundLink", "Classification", "Github", "WeChat", "QQ", "SelfIntroduction", "ProjectExperience", "SatisfiedCustomers", "ReceiveAward", "CoffeeCups",
|
||
"Achievement1Icon", "Achievement1Name", "Achievement1Time", "Achievement1Introduction",
|
||
"Achievement2Icon", "Achievement2Name", "Achievement2Time", "Achievement2Introduction",
|
||
"Achievement3Icon", "Achievement3Name", "Achievement3Time", "Achievement3Introduction",
|
||
"Achievement4Icon", "Achievement4Name", "Achievement4Time", "Achievement4Introduction",
|
||
"Tags", "MarkDown"]
|
||
|
||
@Manage.route("/API/WritePersonalInformation.api", methods=["POST"])
|
||
def UserWritePersonalInformation():
|
||
_=SQLUsers.selectashead(NSQL.MOD.ALL, WHERE=("PersonalPageUserUUID=%s", Get16toBytes(GetELTUserUUID())), FROM="personal", _limit=1)
|
||
r={}
|
||
for i in PersonalForm:
|
||
_r=str(flask.request.form.get(i))
|
||
if i != "MarkDown" and len(_r) > 256: return {"code": 1, "msg": i18n.TooBigMsg(i, "256B")}
|
||
if len(_r) > 64*1024: return {"code": 1, "msg": i18n.TooBigMsg("Markdown", "64KB")}
|
||
if i == "PersonalPageName" and not _r: return {"code": 1, "msg": i18n.BeMostValue("PersonalPageName")}
|
||
if i == "PersonalPageName" and not bool(re.fullmatch(r'^[a-z0-9_]+$', _r)): return {"code": 1, "msg": i18n.Notaz09("PersonalPageName")}
|
||
r[i]=_r
|
||
r["PersonalPageUserUUID"]=Get16toBytes(GetELTUserUUID())
|
||
if r["PersonalPageName"].lower() in BadH:
|
||
return {"code": 1, "msg": i18n.AgainstSystem("PersonalPageName")}
|
||
if not _:
|
||
if SQLUsers.selectashead(NSQL.MOD.ALL, WHERE=("PersonalPageName=%s", r["PersonalPageName"]), FROM="personal", _limit=1):
|
||
return {"code": 1, "msg": i18n.Repeat("PersonalPageName")}
|
||
SQLUsers.insert("personal", **r)
|
||
return {"code": 0, "msg": i18n.ChangeSuccess}
|
||
SQLUsers.update(WHERE=("PersonalPageUserUUID=%s", r["PersonalPageUserUUID"]), FROM="personal", **r)
|
||
return {"code": 0, "msg": i18n.ChangeSuccess}
|
||
|
||
|
||
@Manage.route("/API/RequestPersonalInformation.api")
|
||
def UserRequestPersonalInformation():
|
||
_=SQLUsers.selectashead(NSQL.MOD.ALL, WHERE=("PersonalPageUserUUID=%s", Get16toBytes(GetELTUserUUID())), FROM="personal", _limit=1)
|
||
if not _: return {"code": 1, "msg": i18n.YouNeverRegisterPersonalPage}
|
||
_=_[0]
|
||
del _["PersonalPageUserUUID"]
|
||
return {"code": 0, "data": _}
|
||
|
||
def GetPersonalPage(name):
|
||
if (r:=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="personal", WHERE=("PersonalPageName=%s", name), _limit=1)): return r[0]
|
||
return False
|
||
|
||
@Manage.route("/API/JumpToPersonalPage.api")
|
||
def UserJumpToPersonalPage():
|
||
UserUUID=flask.request.form.get("UserUUID", GetELTUserUUID())
|
||
if not Is_UUID(UserUUID): flask.abort(404)
|
||
if not (r:=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="personal", WHERE=("PersonalPageUserUUID=%s", Get16toBytes(UserUUID)), _limit=1)): flask.abort(404)
|
||
return flask.redirect(f"https://{r[0]["PersonalPageName"]}.gvsds.com")
|
||
|
||
@App.before_request
|
||
def PersonalBeforeRequest():
|
||
h=flask.request.host.lower().split(".")[0]
|
||
if h.lower() in BadH: return None
|
||
if (r:=GetPersonalPage(h)):
|
||
p=ReadUserConfig(GetBytesto16(r["PersonalPageUserUUID"]))
|
||
return flask.render_template("Personal/index.html",
|
||
UserName=p["UserName"],
|
||
UserUUID=GetBytesto16(p["UserUUID"]),
|
||
UserPersonalSignature=p["UserPersonalSignature"],
|
||
UserEmail=p["UserEmail"],
|
||
UserTele=RUserTele(GetBytesto16(p["UserTele"])),
|
||
Subtitle=r["Subtitle"],
|
||
BackgroundLink=r["BackgroundLink"],
|
||
Classification=r["Classification"],
|
||
Github=r["Github"],
|
||
WeChat=r["WeChat"],
|
||
QQ=r["QQ"],
|
||
SelfIntroduction=r["SelfIntroduction"],
|
||
ProjectExperience=r["ProjectExperience"],
|
||
SatisfiedCustomers=r["SatisfiedCustomers"],
|
||
ReceiveAward=r["ReceiveAward"],
|
||
CoffeeCups=r["CoffeeCups"],
|
||
Tags=r["Tags"],
|
||
MarkDown=markdown.markdown(r["MarkDown"]),
|
||
ChildHost=h,
|
||
Achievement1Icon=r["Achievement1Icon"],Achievement1Name=r["Achievement1Name"],Achievement1Time=r["Achievement1Time"],Achievement1Introduction=r["Achievement1Introduction"],
|
||
Achievement2Icon=r["Achievement2Icon"],Achievement2Name=r["Achievement2Name"],Achievement2Time=r["Achievement2Time"],Achievement2Introduction=r["Achievement2Introduction"],
|
||
Achievement3Icon=r["Achievement3Icon"],Achievement3Name=r["Achievement3Name"],Achievement3Time=r["Achievement3Time"],Achievement3Introduction=r["Achievement3Introduction"],
|
||
Achievement4Icon=r["Achievement4Icon"],Achievement4Name=r["Achievement4Name"],Achievement4Time=r["Achievement4Time"],Achievement4Introduction=r["Achievement4Introduction"],
|
||
)
|
||
|
||
@Manage.route("/API/RequestPersonalConfig.api")
|
||
def UserRequestPersonalConfig():
|
||
_=GetELTUserConfig()
|
||
return {
|
||
"UserName": _["UserName"],
|
||
"UserRealName": _["UserRealName"],
|
||
"UserSex": _["UserSex"],
|
||
"UserPersonalSignature": _["UserPersonalSignature"],
|
||
"UserEmail": _["UserEmail"],
|
||
"UserTele": RUserTele(GetBytesto16(_["UserTele"])),
|
||
"UserBornTime": _["UserBornTime"].strftime("%Y-%m-%d %H:%M:%S")
|
||
}
|
||
|
||
|
||
|
||
@Manage.route("/API/GetSeries.api")
|
||
def UserGetSeries():
|
||
_=[]
|
||
ELTUserUUID = GetELTUserUUID()
|
||
if SQLDocument.istrue("series", WHERE=("DocAuthorUserUUID=%s", Get16toBytes(ELTUserUUID))):
|
||
_=SQLDocument.selectashead(NSQL.MOD.ALL,WHERE=("DocAuthorUserUUID=%s", Get16toBytes(ELTUserUUID)), FROM="series")
|
||
_2=[]
|
||
for i in _: _2.append({"DocSerieUUID": GetBytesto16(i["DocSerieUUID"]), "DocSerieName": i["DocSerieName"], "DocAuthorUserUUID": GetBytesto16(i["DocAuthorUserUUID"]), "DocSerieCreateTime": i["DocSerieCreateTime"].strftime("%Y-%m-%d %H:%M:%S")})
|
||
return flask.jsonify({"code":0,"count":1000,"data":_2})
|
||
|
||
def gdfp(s, x):
|
||
if x >= len(s): return 0
|
||
pattern = r'^([0-9]+)'
|
||
match = re.match(pattern, s[x:])
|
||
if match:
|
||
m=match.group(1)
|
||
try: m=int(m)
|
||
except: pass
|
||
return m
|
||
else:
|
||
try: s=int(s)
|
||
except: pass
|
||
return s
|
||
|
||
def dsort(s):
|
||
if len(s) >= 3:
|
||
if s[0] == "第":
|
||
return gdfp(s, 1)
|
||
if s[0:1] == "No":
|
||
return gdfp(s, 2)
|
||
if s[0] in "1234567890":
|
||
return gdfp(s, 0)
|
||
return 0
|
||
|
||
@Manage.route("/API/GetSerieDoces.api")
|
||
def UserGetSerieDoces():
|
||
DocSerieUUID=flask.request.args.get("DocSerieUUID")
|
||
if not DocSerieUUID: return {"code":1,"msg":i18n.NoParameter("DocSerieUUID")}
|
||
if not Get16toBytes(DocSerieUUID, True): return {"code":1,"msg":i18n.NoUUID("DocSerieUUID")}
|
||
if GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="series",WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)))[0]["DocAuthorUserUUID"]) != GetELTUserUUID(): return {"code":1,"msg":i18n.NoPermission}
|
||
_=[]
|
||
if SQLDocument.istrue("doc", WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID))):
|
||
_=SQLDocument.selectashead(NSQL.MOD.ALL,WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)), FROM="doc")
|
||
_2=[]
|
||
for i in _: _2.append({"DocUUID": GetBytesto16(i["DocUUID"]), "DocSerieUUID": GetBytesto16(i["DocSerieUUID"]), "DocTitle": i["DocTitle"], "DocCreateTime": i["DocCreateTime"].strftime("%Y-%m-%d %H:%M:%S")})
|
||
_2=sorted(_2, key=lambda x: dsort(x["DocTitle"]))
|
||
return flask.jsonify({"code":0,"count":1000,"data":_2})
|
||
|
||
@Manage.route("/API/addserie.api", methods=["POST"])
|
||
def UserAddSerie():
|
||
DocSerieName=flask.request.form.get("DocSerieName")
|
||
if not DocSerieName: return {"code":1,"msg":i18n.NoParameter("DocSerieName")}
|
||
if not NonLegalChar(DocSerieName): return {"code":1,"msg":i18n.NotLegalChar("DocSerieName")}
|
||
if len(DocSerieName) > 255: return {"code":1,"msg":i18n.TooBigMsg("DocSerieName", "256B")}
|
||
if SQLDocument.istrue("series", WHERE=("DocSerieName=%s", DocSerieName)): return {"code":1,"msg":i18n.AlreadyExist}
|
||
SQLDocument.insert("series", DocSerieUUID=Get16toInsert(NewUUID()), DocSerieName=DocSerieName, DocAuthorUserUUID=Get16toInsert(GetELTUserUUID()), DocSerieCreateTime=TimeFormatStr("%Y-%m-%d %H:%M:%S"))
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/delserie.api", methods=["POST"])
|
||
def UserDelSerie():
|
||
DocSerieUUID=flask.request.form.get("DocSerieUUID")
|
||
if not DocSerieUUID: return {"code":1,"msg":i18n.NoParameter("DocSerieUUID")}
|
||
if not Get16toBytes(DocSerieUUID, True): return {"code":1,"msg":i18n.NoUUID("DocSerieUUID")}
|
||
if not Get16toBytes(DocSerieUUID, True): return {"code":1,"msg":i18n.NoUUID("DocSerieUUID")}
|
||
if not SQLDocument.istrue("series", WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID))): return {"code":1,"msg":i18n.NotExist}
|
||
SQLDocument.delete("series", WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)))
|
||
SQLDocument.delete("doc", WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)))
|
||
return {"code":1,"msg":i18n.DelSuccess}
|
||
|
||
|
||
@Manage.route("/API/addoc.api", methods=["POST"])
|
||
def UserAddoc():
|
||
DocTitle=flask.request.form.get("DocTitle")
|
||
DocSerieUUID=flask.request.form.get("DocSerieUUID")
|
||
if not DocTitle: return {"code":1,"msg":i18n.NoParameter("DocTitle")}
|
||
if not DocSerieUUID: return {"code":1,"msg":i18n.NoParameter("DocSerieUUID")}
|
||
if not Is_UUID(DocSerieUUID): return {"code":1,"msg":i18n.NoUUID("DocSerieUUID")}
|
||
if not NonLegalChar(DocTitle): return {"code":1,"msg":i18n.NotLegalChar("DocTitle")}
|
||
if len(DocTitle) > 255: return {"code":1,"msg":i18n.TooBigMsg("DocTitle","255B")}
|
||
if DocTitle != "__index" and SQLDocument.istrue("doc", ("DocTitle=%s" , DocTitle)): return {"code":1,"msg":i18n.AlreadyExist}
|
||
if not SQLDocument.istrue("series", WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID))): return {"code":1,"msg":i18n.NotExist}
|
||
if GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="series",WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)))[0]["DocAuthorUserUUID"]) != GetELTUserUUID(): return {"code":1,"msg":i18n.NoPermission}
|
||
SQLDocument.insert("doc", DocUUID=Get16toBytes(NewUUID()), DocSerieUUID=Get16toBytes(DocSerieUUID), DocTitle=DocTitle, DocContent="", DocCreateTime=TimeFormatStr("%Y-%m-%d %H:%M:%S"))
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/writedoc.api", methods=["POST"])
|
||
def UserWriteDoc():
|
||
DocUUID=flask.request.form.get("DocUUID")
|
||
DocContent=flask.request.form.get("DocContent")
|
||
if not DocUUID: return {"code":1,"msg":i18n.NoParameter("DocUUID")}
|
||
if not DocContent: return {"code":1,"msg":i18n.NoParameter("DocContent")}
|
||
if len(DocContent) > 50 * 1024 * 1024: return {"code":1,"msg":i18n.TooBigMsg("DocContent","50M")}
|
||
if not Get16toBytes(DocUUID, True): return {"code":1,"msg":i18n.NoUUID("DocUUID")}
|
||
if not SQLDocument.istrue("doc", ("DocUUID=%s", Get16toBytes(DocUUID))): return {"code":1,"msg":"DOC "+i18n.NotExist}
|
||
DocSerieUUID=GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="doc",WHERE=("DocUUID=%s", Get16toBytes(DocUUID)))[0]["DocSerieUUID"])
|
||
if not SQLDocument.istrue("series", ("DocSerieUUID=%s", Get16toBytes(DocSerieUUID))): return {"code":1,"msg":"SERIE "+i18n.NotExist}
|
||
if GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="series",WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)))[0]["DocAuthorUserUUID"]) != GetELTUserUUID(): return {"code":1,"msg":i18n.NoPermission}
|
||
SQLDocument.update(DocContent=DocContent, FROM="doc", WHERE=("DocUUID=%s", Get16toBytes(DocUUID)))
|
||
return {"code":0,"msg":i18n.AddSuccess}
|
||
|
||
@Manage.route("/API/readdoc.api", methods=["POST"])
|
||
def UserReadDoc():
|
||
DocUUID=flask.request.form.get("DocUUID")
|
||
if not DocUUID: return {"code":1,"msg":i18n.NoParameter("DocUUID")}
|
||
if not Get16toBytes(DocUUID, True): return {"code":1,"msg":i18n.NoUUID("DocUUID")}
|
||
if not SQLDocument.istrue("doc", WHERE=("DocUUID=%s", Get16toBytes(DocUUID))): return {"code":1,"msg":i18n.NotExist}
|
||
DocSerieUUID=GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="doc",WHERE=("DocUUID=%s", Get16toBytes(DocUUID)))[0]["DocSerieUUID"])
|
||
if not SQLDocument.istrue("series", WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID))): return {"code":1,"msg":i18n.NotExist}
|
||
if GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="series",WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)))[0]["DocAuthorUserUUID"]) != GetELTUserUUID(): return {"code":1,"msg":i18n.NoPermission}
|
||
_r=SQLDocument.selectashead(NSQL.MOD.ALL,FROM="doc",WHERE=("DocUUID=%s", Get16toBytes(DocUUID)))[0]
|
||
return {"DocTitle": _r["DocTitle"], "DocContent": _r["DocContent"]}
|
||
|
||
@Manage.route("/API/deldoc.api", methods=["POST"])
|
||
def UserDelDoc():
|
||
DocUUID=flask.request.form.get("DocUUID")
|
||
if not DocUUID: return {"code":1,"msg":i18n.NoParameter("DocUUID")}
|
||
if not Get16toBytes(DocUUID, True): return {"code":1,"msg":i18n.NoUUID("DocUUID")}
|
||
if not SQLDocument.istrue("doc", WHERE=("DocUUID=%s", Get16toBytes(DocUUID))): return {"code":1,"msg":i18n.NotExist}
|
||
DocSerieUUID=GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="doc",WHERE=("DocUUID=%s", Get16toBytes(DocUUID)))[0]["DocSerieUUID"])
|
||
if not SQLDocument.istrue("series", WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID))): return {"code":1,"msg":i18n.NotExist}
|
||
if GetBytesto16(SQLDocument.selectashead(NSQL.MOD.ALL,FROM="series",WHERE=("DocSerieUUID=%s", Get16toBytes(DocSerieUUID)))[0]["DocAuthorUserUUID"]) != GetELTUserUUID():
|
||
return "此表单提供的系列不由cookie记录的账户管理"
|
||
SQLDocument.delete("doc", WHERE=("DocUUID=%s", Get16toBytes(DocUUID)))
|
||
return {"code":0,"msg":i18n.DelSuccess}
|
||
|
||
|
||
|
||
from flask_wtf import FlaskForm
|
||
from flask_wtf.csrf import validate_csrf
|
||
from wtforms import SubmitField, HiddenField
|
||
from wtforms.validators import DataRequired
|
||
|
||
|
||
@Manage.route("/User/checkin.html")
|
||
def UserCheckInPage():
|
||
return flask.render_template("Manage/User/checkin.html")
|
||
|
||
@Manage.route("/API/CheckInStatus.api")
|
||
def UserCheckInStatusAPI():
|
||
_=GetELTUserConfig()["UserLastCheckInDate"]
|
||
if not _: return flask.jsonify({"code": 0, "checkin": False})
|
||
if _.date() == datetime.datetime.today().date(): return flask.jsonify({"code": 0, "checkin": True})
|
||
return flask.jsonify({"code": 0, "checkin": False})
|
||
|
||
class CheckInForm(FlaskForm):
|
||
csrf_token = HiddenField(validators=[DataRequired()])
|
||
|
||
@Manage.route("/API/CheckIn.api", methods=["POST"])
|
||
@PreRequirements(2.0)
|
||
def UserCheckInAPI():
|
||
checkin=CheckInForm()
|
||
if not checkin.validate_on_submit():
|
||
return flask.jsonify({"code": 1, "msg": i18n.CheckInError})
|
||
try: validate_csrf(checkin.csrf_token.data)
|
||
except: return flask.jsonify({"code": 1, "msg": i18n.CheckInError})
|
||
_ = GetELTUserConfig()["UserLastCheckInDate"]
|
||
if hasattr(_, "date") and _ and _.date() == datetime.datetime.today().date():
|
||
return flask.jsonify({"code": 1, "msg": i18n.AlreadyCheckIn})
|
||
WriteELTUserConfigI("UserLastCheckInDate", TimeFormatInt())
|
||
ELTUserUUID = GetELTUserUUID()
|
||
GC = -1
|
||
if (r:=GetMCMarketByGVSDSUUID(ELTUserUUID)):
|
||
GC = random.randint(0,500)
|
||
SQLMinecraft.update(FROM="server_market_balances", WHERE=("uuid=%s", r[0]["uuid"]), amount=r[0]["amount"] + GC)
|
||
SQLUsers.insert("checkin", UserUUID=Get16toBytes(ELTUserUUID), WeekFirstTime=GetWeekStartDate(), CheckInTime=TimeFormatStr())
|
||
return flask.jsonify({"code": 0, "GC": GC})
|
||
|
||
@Manage.route("/API/GetNewCheckIn.api")
|
||
@PreRequirements(2.0)
|
||
def UserGetNewCheckIn():
|
||
_r=[]
|
||
for i in SQLUsers.selectashead(NSQL.MOD.ALL, FROM="checkin", WHERE="1=1", _limit=16*3, WITH="ORDER BY CheckInTime DESC"):
|
||
if not (_u:=SQLUsers.selectashead(NSQL.MOD.ALL, FROM="usersub", WHERE=("UserUUID=%s", i["UserUUID"]))):
|
||
_r.append({"name":i18n.Cancelled, "avatar":"/assets/img/UserDefaultImg.png", "signin_time": i["CheckInTime"].strftime("%Y-%m-%d %H:%M:%S"), "firstweek_time": i["WeekFirstTime"].strftime("%Y-%m-%d")})
|
||
continue
|
||
_u=_u[0]
|
||
_r.append({"name":_u["UserName"], "avatar":f"https://ugm.gvsds.com/GetArgsUserHeadPng.api?UserUUID={GetBytesto16(_u["UserUUID"])}", "signin_time": i["CheckInTime"].strftime("%Y-%m-%d %H:%M:%S"), "firstweek_time": i["WeekFirstTime"].strftime("%Y-%m-%d")})
|
||
return {"code": 0, "data": _r}
|
||
|
||
|
||
@Manage.route("/API/GetLJUMPM.api")
|
||
def ManageGetLJUMPM():
|
||
return {"code": GetELTUserConfig()["UserLoginJump"]}
|
||
|
||
@Manage.route("/API/GetTheme.api")
|
||
def ManageGetTheme():
|
||
return {"code": GetELTUserConfig()["UserTheme"]}
|
||
|
||
@Manage.route("/API/GetPhotoViewPort.api")
|
||
def ManageGetPhotoViewPort():
|
||
return {"code": GetELTUserConfig()["UserPhotoViewPort"]}
|
||
|
||
@Manage.route("/API/SetLJUMPM.api", methods=["POST"])
|
||
def ManageSetLJUMPM():
|
||
Jump=flask.request.form.get("Jump")
|
||
if not Jump: return {"code": 1, "msg": i18n.NoParameter("Jump")}
|
||
if Jump not in ["0", "1"]: return {"code": 1, "msg": i18n.ModeError}
|
||
SQLUsers.update(UserLoginJump=int(Jump), FROM="usersub", WHERE=("UserUUID=%s", Get16toBytes(GetELTUserUUID())))
|
||
return {"code": 0, "msg": i18n.OperateSuccess}
|
||
|
||
@Manage.route("/API/SetTheme.api", methods=["POST"])
|
||
def ManageSetTheme():
|
||
Theme=flask.request.form.get("Theme")
|
||
if not Theme: return {"code": 1, "msg": i18n.NoParameter("Theme")}
|
||
if not os.path.isfile(os.path.join(TempLate, f"Manage/css/theme{str(Theme)}.css")): return {"code": 0, "msg": i18n.NoFound("ThemeCSS")}
|
||
SQLUsers.update(UserTheme=int(Theme), FROM="usersub", WHERE=("UserUUID=%s", Get16toBytes(GetELTUserUUID())))
|
||
return {"code": 0, "msg": i18n.OperateSuccess}
|
||
|
||
@Manage.route("/API/SetPhotoViewPort.api", methods=["POST"])
|
||
def ManageSetPhotoViewPort():
|
||
PhotoViewPort=flask.request.form.get("PhotoViewPort")
|
||
if not PhotoViewPort: return {"code": 1, "msg": i18n.NoParameter("PhotoViewPort")}
|
||
if PhotoViewPort not in ["0", "1"]: return {"code": 1, "msg": i18n.ModeError}
|
||
SQLUsers.update(UserPhotoViewPort=int(PhotoViewPort), FROM="usersub", WHERE=("UserUUID=%s", Get16toBytes(GetELTUserUUID())))
|
||
return {"code": 0, "msg": i18n.OperateSuccess}
|
||
|
||
@Manage.route("/css/theme.css")
|
||
def ManageThemeCSS():
|
||
return flask.Response(openr(os.path.join(TempLate, f"Manage/css/Theme{GetELTUserConfig()["UserTheme"]}.css")), mimetype="text/css")
|
||
|
||
@Manage.before_request
|
||
def ManageBeforeRequest():
|
||
#return flask.render_template("Manage/workonit.html")
|
||
allowsu=["txt", "png", "jpg", "gif", "js", "css", "eot", "svg", "tff", "woff", "woff2"]
|
||
if flask.request.url.split(".")[-1].lower() not in allowsu and not Is_ELTUser():
|
||
return flask.redirect(flask.url_for("MainLoginHTML"))
|
||
|
||
#App.jinja_env.globals.update
|
||
App.register_blueprint(Manage)
|
||
|
||
|
||
|
||
Verify=flask.Blueprint("verify", __name__, subdomain="verify",static_folder=TempLate + "/verify",static_url_path="/")
|
||
@Verify.route("/")
|
||
def VerifyIndex():
|
||
if not Is_ELTUser():
|
||
return flask.render_template("/Verify/index_de.html")
|
||
ELTUserConfig=GetELTUserConfig()
|
||
Permission=int(float(ELTUserConfig["UserPermissions"]))
|
||
PermissionWord={5: "A",4: "B",3: "C",2: "D",1: "E"}.get(Permission, "UK")
|
||
PermissionWork={5: ["系统管理员", "网络架构配置与管理", "防火墙与入侵检测系统管理", "安全事件响应与处置", "网络流量监控与分析", "最高权限"],4: ["组管理员", "网络架构配置与管理", "防火墙与入侵检测系统管理", "安全事件响应与处置", "网络流量监控与分析"],3: ["委员会成员", "可读取", "可修改", "禁止越权", "网络架构配置与管理", "防火墙与入侵检测系统管理", "安全事件响应与处置", "系统漏洞扫描与修复", "网络流量监控与分析"],2: ["组成员", "可读取", "禁止修改", "禁止越权"],1: ["用户", "可读取", "禁止修改", "禁止越权"]}.get(Permission, "UK")
|
||
PermissionWork2={5: ["允许修改全部 ELT 凭证", "可本地写入读取，可服务器写入读取"],4: ["允许修改全部 ELT 凭证", "可本地写入读取，可服务器写入读取"],3: ["允许修改部分 ELT 凭证", "可本地写入读取，可服务器写入读取"],2: ["禁止修改 ELT 凭证", "可本地写入读取"],1: ["禁止修改 ELT 凭证", "可本地写入读取"]}.get(Permission, "UK")
|
||
VerifyStatus={5: "SYSTEM OVERSEER",4: "GROUP AGENT",3: "COMMITTEE AGENT",2: "GROUP",1: "USER"}.get(Permission, "UK")
|
||
return flask.render_template("/Verify/index.html",
|
||
UserName=StrMinus(ELTUserConfig["UserName"], 20),
|
||
Permission=Permission,
|
||
PermissionWord=PermissionWord,
|
||
UserCreatime=ELTUserConfig["UserCreatime"].strftime("%Y-%m-%d %H:%M:%S"),
|
||
UserLastLoginDate=ELTUserConfig["UserLastLoginDate"].strftime("%Y-%m-%d %H:%M:%S"),
|
||
UserUUID=GetBytesto16(ELTUserConfig["UserUUID"]).upper(),
|
||
UserJob=ELTUserConfig["UserJob"],
|
||
VerifyStatus=VerifyStatus,
|
||
PermissionWork=PermissionWork,
|
||
PermissionWork2=PermissionWork2,
|
||
)
|
||
@Verify.route("/index.html")
|
||
def VerifyIndexHtml():
|
||
return flask.redirect(flask.url_for("Verify.VerifyIndex"))
|
||
App.register_blueprint(Verify) |