async def make_response_json(code: int = 200, message: str = None, data: dict = None, error_code: int = None) -> BaseHTTPResponse:
if data is not None:
return JsonResponse(data)
if message is None:
message = HTTPStatus(code).phrase
if error_code is None:
error_code = code
data = {
'code': error_code,
'message': message
}
return JsonResponse(data, status=code)
async def tableList(request):
return_list = []
for key, value in class_dic.items():
return_list.append({
"table_name_j": value.verbose_name,
"table_name_e": key
})
return JsonResponse(return_list)
async def post(self, request):
if not request.form:
raise ParamsNotFound("param not found")
form_data = request.form
sql = inset_sql(self.table.table_name, query_field=form_data.keys())
await request.app.db.execute(sql, *list(form_data.values()))
return JsonResponse({
"code": 1,
"msg": "添加完成",
})
async def get(self, request, obj_id):
sql = querySql(self.table.table_name,
query_field=self.table.query_field,
where_field=[self.table.primary_key],
where_func="=",
count="",
join_sql=self.table.join_sql)
result = await request.app.db.get(sql, obj_id)
result = json.dumps(result, cls=JsonExtendEncoder)
return JsonResponse(json.loads(result))
async def objTable(request, func):
try:
table_obj = class_dic.get(func)()
except TypeError:
raise NotFound("Requested URL {} not found".format("/table/func"))
return JsonResponse({
"primary_key": table_obj.primary_key,
"table_name": table_obj.verbose_name,
"columns": table_obj.getList
})
async def delete(self, request, obj_id):
sql = "DELETE FROM {} WHERE {}=%s;".format(self.table.table_name,
self.table.primary_key)
await request.app.db.execute(
sql,
obj_id,
)
return JsonResponse({
"code": 1,
"msg": "成功删除",
})
async def put(self, request, obj_id):
if not request.form:
raise ParamsNotFound("param not found")
await request.app.db.table_update(self.table.table_name,
updates=request.form,
field_where=self.table.primary_key,
value_where=obj_id)
return JsonResponse({
"code": 1,
"msg": "更新成功",
})
async def slide_code(request):
"""请求验证码数据"""
wtf = TokenWtf(request)
print(wtf.token)
status = verify_bearer_token(wtf.token.data)
if not status:
return JsonResponse({"status": 403, "msg": "登录验证码授权token校验失效"})
width = 360
height = 176
img = file_name("static")
img_src = random.choice(img)
pl_size = 48
padding = 20
_min_x = pl_size + padding
_max_x = width - padding - pl_size - pl_size // 6
_min_y = height - padding - pl_size - pl_size // 6
_max_y = padding
deviation = 4 # 滑动偏移量
x = await random_num(_min_x, _max_x)
y = await random_num(_min_y, _max_y)
request["session"]["coords"] = [x - deviation, x + deviation]
request["session"]["coordY"] = y
print("code------>", x, y)
return JsonResponse({
"status": 200,
"msg": "SUCCESS",
"data": {
"img_src": img_src,
"x": x,
"y": y
}
})
async def make_response_json(code: int = 200,
message: str = None,
data: dict = None,
error_code: int = None,
**kwargs) -> BaseHTTPResponse:
response_kwargs = dict(
ensure_ascii=False,
escape_forward_slashes=False,
)
response_kwargs.update(kwargs)
if data is not None:
return JsonResponse(data, **response_kwargs)
if message is None:
message = HTTPStatus(code).phrase
if error_code is None:
error_code = code
data = {'code': error_code, 'message': message}
return JsonResponse(data, status=code, **response_kwargs)
async def get(self, request):
self.set_page(request)
keyword = self.get_keyword(request)
sql = self.get_query_sql()
db = request.app.db
if not db.pool:
await db.init_pool()
async with db.pool.acquire() as conn:
async with conn.cursor() as cur:
try:
await cur.execute(sql, keyword)
ret1 = await cur.fetchall()
except pymysql.err.InternalError:
await conn.ping()
await cur.execute(sql, keyword)
ret1 = await cur.fetchall()
try:
await cur.execute("select found_rows() as count;")
ret2 = await cur.fetchone()
except pymysql.err.InternalError:
await conn.ping()
await cur.execute("select found_rows() as count;")
ret2 = await cur.fetchone()
data, count = ret1, ret2.get("count")
# data,count = (await request.app.db.data_and_count(sql, *keyword))
choice_field, foreignkey_field = self.table.get_choice_and_foreignkey()
for obj in data:
for choice, choice_obj in choice_field.items():
obj[choice] = choice_obj.choice_field.get(obj[choice])
for foreignkey, foreignkey_obj in foreignkey_field.items():
obj[foreignkey] = "{}\n（{}）".format(
obj[foreignkey], obj[foreignkey_obj.key_name])
del obj[foreignkey_obj.key_name]
data = json.dumps(data, cls=JsonExtendEncoder)
int_count, float_count = divmod(count, self.page_size)
if float_count:
int_count += 1
return JsonResponse({
"data_count": count,
"max_page": int_count,
"page": self.page,
"data": json.loads(data),
})