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: '%s' % x, l)))
#给删了
def GetUserPositionStatusStr(UserPositionStatus):
if UserPositionStatus == 1: return "在职"
else: return "停职"
@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","
"),
TaskOther=TaskInFo["TaskOther"].replace(r"\n","
"),
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)