def get(self):
# 刷新商户经理获取抢单列表
logger.info("[D] [功能 刷新商户经理获取抢单列表]")
req = self.validate_data
logger_req(req)
manager = request.current_user
refresh_face_sign(manager.code)
# 筛选条件
time_start = req.get("time_start", "")
time_end = req.get("time_end", "")
address_code = req.get("address_code", "")
orderby_time = req.get("orderby_time", "")
a = TbFaceSignUser.merchant_code == manager.merchant_code # 商户编码
b = (TbFaceSignUser.order_time >= time_start
) if time_start else True # 预约起始起始时间
c = (TbFaceSignUser.order_time <= time_end
) if time_end else True # 预约结束时间
d = (TbFaceSignUser.order_address_code.op("regexp")(
r"^" +
re_address_code(address_code))) if address_code else True # 省市区筛选
e = TbFaceSignUser.status == 0 # 状态为待面签条件
f = (TbFaceSignUser.update_time) if orderby_time == "1" else (
-TbFaceSignUser.update_time) # 时间正反序
ke = [a, b, c, d, e]
facesign = TbFaceSignUser.query.filter(*ke).order_by(f)
return get_data(
facesign,
TbFaceSignUser,
exclude=["id", "manager_code", "manager_name", "extend"])
def put(self):
"""更新产品信息"""
schema = Schema({
"production_code": And(str),
"appkey": And(str),
"appid": And(str),
"sign": And(str)
})
req, error = validate_schema(schema, request.json)
if error:
return error, 400
production = TbProduction.query.filter_by(
code=req["production_code"]).first()
if not production:
return Msg.PRODUCTION_NOT_EXIST, 400
production.sms_appkey = req["appkey"]
production.sms_appid = req["appid"]
production.sms_sign = req["sign"]
msg = "SUPPORT | B_USER | UPDATE_PRODUCTION | SUCCESS | EDITOR: {} {} | PRODUCTION: {} {} | MERCHANT: {} {}".\
format(request.current_user.code, request.current_user.name, production.code, production.name,
production.merchant.code, production.merchant.name)
operation = TbOperation(operator_code=request.current_user.code,
content=msg,
category="PRODUCTION",
type="EDIT")
db.session.add(operation)
db.session.commit()
logger.info(msg)
return {}, 200
def dispatch_request(self, *args, **kwargs):
req = None
schema = None
if request.method == "GET":
schema = self.validate_schemas.get("get")
req = request.args.to_dict()
else:
schema = self.validate_schemas.get(request.method.lower())
req = request.json
if isinstance(schema, Schema):
data, errors = validate_schema(schema, move_space(req))
if errors:
logger.info(str(errors))
return str(errors), 400
self.validate_data = data
try:
ret = super().dispatch_request(*args, **kwargs)
return ret
except NotUniqueError:
logger.warn(traceback.format_exc())
return Msg.DATA_EXIST, 400
except ValidationError as e:
logger.warn(traceback.format_exc())
return str(e), 400
except DoesNotExist:
logger.warn(traceback.format_exc())
return Msg.NO_DATA, 400
except AttributeError as e:
logger.warn(traceback.format_exc())
return str(e), 400
except Exception as e:
logger.warn(traceback.format_exc())
return str(e), 400
def put(self):
schema = Schema({
"id": And(str),
"businessId": And(str),
"path": And(str, len),
"name": And(str, len),
"visible": And(bool)
})
req, error = validate_schema(schema, request.json)
if error:
return error, 400
menu = TbMenu.query.filter_by(code=req["id"]).first()
if not menu:
return Msg.MENU_NOT_EXIST, 400
business = TbBusiness.query.filter_by(code=req["businessId"]).first()
if not business:
return Msg.BUSINESS_NOT_EXIST, 400
menu.name = req["name"]
menu.path = req["path"]
menu.business_code = business.code
menu.visible = req.get("visible")
msg = "SUPPORT | B_USER | EDIT_MENU | SUCCESS | USER: {} {} | MENU: {} {} {}".format(
request.current_user.code, request.current_user.name, menu.code, menu.name, menu.path)
operation = TbOperation(operator_code=request.current_user.code, content=msg, category="MENU", type="EDIT")
db.session.add(operation)
db.session.commit()
logger.info(msg)
return {}, 200
def post(self):
req = add_user.parse_args(strict=True)
merchant = TbMerchant.query.filter_by(code=req["merchantId"]).first()
if not TbMerchant:
return Msg.MERCHANT_NOT_EXIST, 400
phone = req["mobile"]
if len(phone) != 11 or TbUser.query.filter_by(phone=phone).first():
return Msg.PHONE_USED, 400
user = TbUser(
phone=phone,
name=req.get("name"),
sex=req.get("sex"),
wechat=req.get("wechat"),
qq=req.get("qq"),
mail=req.get("mail"),
address=req.get("address"),
merchant_code=merchant.code,
)
user.generate_password("123456")
merchant.users.append(user)
db.session.add(user)
db.session.commit()
user.code = str(1000000000 + user.id)
msg = "SUPPORT | B_USER | EDIT_USER | SUCCESS | EDITOR: {} {} | USER: {} {} | MERCHANT: {} {}".format(
request.current_user.code, request.current_user.name, user.code,
user.name, merchant.code, merchant.name)
operation = TbOperation(operator_code=user.code,
content=msg,
category="USER_MANAGE",
type="ADD")
db.session.add(operation)
db.session.commit()
logger.info(msg)
return {}, 200
def post(self):
instance, errors = self.detail_schema.load(request.json)
if errors:
logger.info(str(errors))
return str(errors), 400
instance.save()
return self.detail_schema.dump(instance).data
def put(self):
"""
修改用户密码
"""
req = modify_password.parse_args(strict=True)
if req["newPassword"] != req["verifyPassword"]:
return Msg.PARAMS_ERROR, 400
user = request.current_user
if user.verify_password(req["oldPassword"]):
user.generate_password(req["newPassword"])
db.session.commit()
key = "support_jwt_{}".format(request.current_user.code)
redis_delete(key)
msg = "SUPPORT | B_USER | MODIFY_PASSOWRD | SUCCESS | USER_CODE: {} | USER_NAME: {}".format(
user.code, user.name)
operation = TbOperation(operator_code=user.code,
content=msg,
category="USER",
type="EDIT")
db.session.add(operation)
db.session.commit()
logger.info(msg)
return {}, 200
return Msg.OLD_PASSWORD_ERROR, 400
def put(self):
schema = Schema({
"id": And(str),
"businessId": And(str),
"path": And(str, len),
"method": And(str, len),
"name": And(str, len),
"visible": And(bool)
})
req, error = validate_schema(schema, request.json)
if error:
return error, 400
interface = TbInterface.query.filter_by(code=req["id"]).first()
if not interface:
return Msg.INTERFACE_NOT_EXIST, 400
business = TbBusiness.query.filter_by(code=req["businessId"]).first()
if not business:
return Msg.BUSINESS_NOT_EXIST, 400
interface.name = req["name"]
interface.path = req["path"]
interface.method = req["method"]
interface.business_code = business.code
interface.visible = req["visible"]
msg = "SUPPORT | B_USER | EDIT_INTERFACE | SUCCESS | USER: {} {} | INTERFACE: {} {} {}".format(
request.current_user.code, request.current_user.name, interface.code, interface.name, interface.path)
operation = TbOperation(operator_code=request.current_user.code, content=msg, category="INTERFACE", type="EDIT")
db.session.add(operation)
db.session.commit()
logger.info(msg)
return {}, 200
def get(self):
logger.info("[D] [功能 案件信息展示]")
req = self.validate_data
logger_req(req)
phone = req.get("phone","")
name = req.get("name","")
case_type = req.get("case_type")
id_card = req.get("id_card")
merchant_code = req.get("merchant_code")
time_start = req.get("time_start","")
time_end = req.get("time_end","")
trx = req.get("trx","")
production_code = req.get("production_code","")
#筛选
a = LogCase.merchant_code == merchant_code if merchant_code else True # 商户编码
b = LogCase.phone == phone if phone else True # 电话号码
c = LogCase.name.contains(name) if name else True # 用户姓名模糊查询
d = LogCase.case_type == case_type if case_type else True # 事件类型
e = LogCase.id_card == id_card if id_card else True # 身份证
f = (LogCase.trigger_time >= time_start) if time_start else True # 起始起始时间
g = (LogCase.trigger_time <= time_end) if time_end else True # 结束时间
h = (LogCase.trx == trx) if trx else True # 单号查询
i = (LogCase.production_code == production_code) if production_code else True # 产品号查询
ke = [a, b, c, d, e, f, g, h,i]
case = LogCase.query.filter(*ke).order_by(-LogCase.trigger_time)
return get_data(case, LogCase, exclude=["id","data"])
def get(self):
self.reqparse.add_argument("trx",
type=str,
required=True,
nullable=False,
code=1014010001,
desc="事务ID")
self.reqparse.add_argument("type",
type=str,
required=False,
code=1014010001,
desc="数据类型")
rq_args = self.reqparse.parse_args(strict=True)
trx = rq_args.get("trx", "")
search_type = rq_args.get("type", "")
search_list = self.verification_search_type(search_type)
if not trx:
raise RequestsError(code=1014010001, message=',事务ID不能为空')
# 查询所有接口配置信息
self.interface_dict = self.get_interfaces()
ret_data = dict()
for tp in search_list:
ret_data[tp] = eval('self.{0}'.format(tp))(trx)
logger.info(
"success queried credit detail information,query parameters are %s"
% json.dumps(rq_args))
return ret_data
def read_config_from_mongo(app):
# 读取 mongodb 里面的配置
config = support_config_db.find_one()
if not config:
logger.info("NO CONFIG IN MONGODB")
else:
logger.info("READING CONFIG FROM MONGODB | CONFIG: {}".format(config))
app.config.update(config if config else {})
def post(self):
instance = self.model(**request.json)
try:
instance.save()
except Exception as e:
logger.info(str(e))
return str(e), 400
return instance.to_dict()
def push_merchant(merchant) -> tuple:
"""
推送商户信息
"""
url = zk.loan_mng_hosts
if not url:
return False, "未找到信贷核心地址"
params = {
"ctrlData": {
"servcId": "AS_BANK_ACCOUNT_UPDATE",
"servcScn": "01",
"sysIndicator": "000001",
"reqTime": time.strftime("%Y-%m-%d %H:%M:%S"),
"transMedium": "00000000",
"bizTrackNo": "{}".format(time.time() * 10000000),
"transSeqNo": "{}".format(time.time() * 10000000),
"hostIp": ip,
},
"body": {
"reqHead": {
"bankNo": merchant.code,
"custId": merchant.code
},
"bankName": merchant.name,
"openFlag": "1",
"acctSelfInd": "1",
"merchNo": merchant.xw_code,
"loanAcctNo": merchant.iba_loan_no,
"loanAcctName": merchant.iba_loan_name,
"deduAcctNo": merchant.iba_collection_no,
"deduAcctName": merchant.iba_collection_name,
"preAcctNo": merchant.iba_pre_deposit_no,
"preAcctName": merchant.iba_pre_deposit_name,
"assetsImpairmentNum": "90",
"orgNo": merchant.org_no
}
}
if merchant.push_flag == 0:
params["body"].update({"operType": "1"})
else:
params["body"].update({"operType": "2"})
try:
res = requests.post(url + "/loan_mng/handle", json=params).json()
code = res["respData"]["code"]
if code == "00000000":
merchant.push_flag = 1
db.session.commit()
logger.info("PUSH MERCHANT SUCCESS!")
return True, ""
else:
logger.warn(
"push merchant info failed, failed info {}".format(res))
return False, res.get("respData", {}).get("message") or str(res)
except Exception as e:
logger.warn("push merchant info failed, failed info {}".format(str(e)))
return False, "网络错误"
def get(self):
list_fields = [
'trx', 'cmd_id', 'rule_id', 'phone', 'merchant_code',
'production_code', 'exec_way', 'recover_index', 'can_recover',
'message', 'operate_status', 'operator', 'operator_id', 'stime',
'state'
]
data = self.validate_data
start_time = data.get('start_time')
end_time = data.get('end_time')
page = data.pop('page')
page_size = data.pop('page_size')
index_suffix = data.pop('index_suffix')
index = 'schedurun' + index_suffix
filters = []
if start_time:
filters.append({"range": {"stime": {"gte": start_time}}})
data.pop('start_time')
if end_time:
filters.append({"range": {"stime": {"lte": end_time}}})
data.pop('end_time')
# 精确搜索text字段使用keyword（建索引的时候指定了该字段为keyword）
data = {
"%s.keyword" % k if isinstance(v, str) else k: str(v)
for k, v in data.items()
}
query = [Q("term", **{k: v}) for k, v in data.items()]
filters.extend(query)
search = ScheduRun.search(using=es_client, index=index).query(
'bool', filter=filters).source(list_fields).sort('-stime.keyword')
logger.info("ES query: %s" % search.to_dict())
total = search.count()
page_search = search[(page - 1) * page_size:page * page_size]
page_results = page_search.execute(ignore_cache=True)
results = []
for ret in page_results:
tmp = dict()
ret_dict = ret.to_dict(include_meta=True)
tmp = ret_dict['_source']
tmp['id'] = ret_dict['_id']
tmp['index'] = ret_dict['_index']
tmp['operate_status'] = ret.operate_status
tmp['operator'] = ret.operator
tmp['operator_id'] = ret.operator_id
results.append(tmp)
return {
"total": total,
"pages": math.ceil(total / page_size),
"page": page,
"page_size": page_size,
"results": results
}
def get_config(self, category):
path = ConfigNameMap.zk_path[category]
if not self.zk.exists(path):
self.zk.create(path, json.dumps({}).encode())
try:
data = json.loads(self.zk.get(path)[0].decode())
return data
except Exception as e:
logger.info("ZK | GET CONFIG | FAILED | CATEGORY: {}| ERROR: {}".format(category, str(e)))
return {}
def get(self):
"""
获取租户对应产品所拥有征信源
:return: 租户对应产品所拥有征信源详情
"""
# 里面更新征信源的可用状态将自动更新interface_status
self.reqparse.add_argument("merchant_code",
type=str,
required=True,
location=["json", "args"],
code=1014010001,
desc="租户id")
self.reqparse.add_argument("production_code",
type=str,
required=True,
location=["json", "args"],
code=1014010001,
desc="产品id")
self.reqparse.add_argument("interface_status",
type=int,
location=["json", "args"],
code=1014010002,
desc="三方接口可用状态")
rq_args = self.reqparse.parse_args(strict=True)
query_dict = {
"merchant_code": rq_args.get("merchant_code", ""),
"production_code": rq_args.get("production_code", ""),
"interface_status": rq_args.get("interface_status", ""),
}
type_orm = {"third_zx": "三方征信", "rh_zx": "人行征信"}
query_dict = {k: v for k, v in query_dict.items() if v is not None}
query_dict["is_delete"] = 0
full_merchant_list = self.get_interface_mysql(query_dict)
full_interface_dict = self.mongo_full_interface()
interface_merchant_list, wait_update_list = self.format_data(
full_interface_dict, full_merchant_list, query_dict)
if wait_update_list:
self.to_post_put(TbMerchantCredit, wait_update_list)
ret_dict = {}
for data in interface_merchant_list.values():
for k, v in data.items():
if v != 0 and not v: # 此处value可能为0
data.update({k: ""})
type_zx = type_orm.get(data["type"], data["type"])
if type_zx in ret_dict:
ret_dict[type_zx].append(data)
else:
ret_dict[type_zx] = [data]
log_data = "SUPPORT | MARCHANT_CREDIT | GET_MARCHANT_CREDIIT | SUCCESS | MERCHANT:{} | PRODUCT: {}".\
format(query_dict["merchant_code"], query_dict["production_code"])
logger.info(log_data)
return {
"total": len(ret_dict),
"results": json.loads(json.dumps(ret_dict))
}
def get_os_center_hosts(self, *args):
try:
children = self.zk.get_children(self.os_center_node)
node = children[0]
data = self.zk.get(self.os_center_node+"/"+node)[0].decode()
host = "http://{}".format(data)
logger.info("ZK | GET OS_CENTER HOSTS | SUCCESS | HOST: {}".format(host))
return host
except Exception as e:
logger.info("ZK | GET OS_CENTER HOSTS | FAILED | ERROR: {}".format(str(e)))
return ""
def write_config(self, category, config):
path = ConfigNameMap.zk_path[category]
try:
self.zk.ensure_path(path)
if not self.zk.exists(path):
self.zk.create(path, json.dumps({}).encode())
self.zk.set(path, json.dumps(config).encode())
return True
except Exception as e:
logger.info("ZK | SYNC CONFIG | FAILED | CATEGORY: {}| ERROR: {}".format(category, str(e)))
return False
def get_loan_mng_hosts(self, *args):
try:
data = json.loads(self.zk.get(self.node)[0])
ip = data["node_list"][0]["ip"]
port = data["node_list"][0]["port"]
host = "http://{}:{}".format(ip, port)
logger.info("ZK | GET LOAN_MNG HOSTS | SUCCESS | HOST: {}".format(host))
self.loan_mng_hosts = host
return host
except Exception as e:
logger.info("ZK | GET LOAN_MNG HOSTS | FAILED | ERROR: {}".format(str(e)))
self.loan_mng_hosts = ""
def put(self):
schema = Schema({
"id": And(str),
"name": And(str, len),
"businessId": And(str),
"interface": [str],
"menu": [str]})
req, error = validate_schema(schema, request.json)
if error:
return error, 400
user = request.current_user
code = req["id"]
name = req.get("name")
business_code = req.get("businessId")
interface = req.get("interface")
menu = req.get("menu")
condition = [TbRole.name == name, TbRole.code != code, TbRole.business_code == business_code]
if user.merchant:
condition.append(TbRole.merchant_code == user.merchant_code)
else:
condition.append(TbRole.merchant_code == None)
dup_role = TbRole.query.filter(*condition).first()
if dup_role:
return Msg.ROLE_NAME_ALREADY_EXIST, 400
biz = TbBusiness.query.filter_by(code=business_code).first()
if not biz:
return Msg.BUSINESS_NOT_EXIST, 400
role = TbRole.query.filter_by(code=code).first()
# 只允许 admin 用户修改用户中心角色
if not user.is_admin and role.business.appid == app.config["USER_CENTER"]:
msg = "SUPPORT | B_USER | EDIT_ROLE | FAILED | USER: {} {} | ROLE: {} {} | REASON | {}".format(
user.code, user.name, role.code, role.name, "user has not permission to edit role")
logger.info(msg)
return Msg.PARAMS_ERROR, 400
if not role:
return Msg.ROLE_NOT_EXIST, 400
role.name = name
role.interface.clear()
role.menu.clear()
role.business = biz
data = role_insert(role, interface, menu)
if data == {}:
msg = "SUPPORT | B_USER | EDIT_ROLE | SUCCESS | USER: {} {} | ROLE: {} {}".format(
user.code, user.name, role.code, role.name)
operation = TbOperation(operator_code=user.code, content=msg, category="ROLE", type="ADD")
db.session.add(operation)
db.session.commit()
logger.info(msg)
return data, 200
else:
db.session.rollback()
return data, 400
def put(self):
# 修改当前客户经理相关信息
logger.info("[D] [功能 修改当前客户经理相关信息]")
req = self.validate_data
logger_req(req)
manager = request.current_user
manager.address = req.get("address", manager.address)
manager.head_img = req.get("head_img", manager.head_img)
db.session.commit()
logger.info("[T] [Update tb_manager where manager_code= {}]".format(
manager.code))
return ""
def get(self):
"""
获取任务分配待审核数量，未分配数量, 已分配数量
"""
evt_type = self.validate_data.get("evt_type")
queryset = Evt.objects(evt_type=evt_type)
un_allot_cnt = queryset(operator_id=None).count()
writing_audit_cnt = queryset(status__in=[0, 4]).count()
total_count = queryset.count()
allot_cnt = total_count - un_allot_cnt
logger.info("获取%s任务分配数量 待审核数量:%s , 未分配数量:%s, 已分配数量:%s" %
(evt_type, writing_audit_cnt, un_allot_cnt, allot_cnt))
return {"un_allot_cnt": un_allot_cnt, "allot_cnt": allot_cnt, "writing_audit_cnt": writing_audit_cnt}
def put(self):
_id = request.json.pop("id")
instance = self.model.objects().filter(id=_id).first()
if not instance:
return Msg.NO_DATA, 400
exclude_fields = set(request.json.keys()) & set(
self.update_exclude_fields)
include_fields = set(request.json.keys()) - set(
self.update_include_fields)
if self.update_include_fields and include_fields:
logger.info("Not Allowed To Update " + str(include_fields))
return "Not allowed to update " + str(include_fields), 400
if exclude_fields:
logger.info("Not Allowed To Update " + str(exclude_fields))
return "Not allowed to update " + str(exclude_fields), 400
status = request.json.get("status")
if status:
regional_total = RegionalControl.objects.filter(
production_code=instance.production_code, status=True).count()
if regional_total >= self.regional_total:
logger.info(
f"living regional_control can not more than {self.regional_total}"
)
return f"living regional_control can not more than {self.regional_total}", 400
instance.update_time = int(datetime.utcnow().timestamp())
try:
instance.update(**request.json)
instance.save()
except Exception as e:
logger.info(str(e))
return str(e), 400
return instance.to_dict()
def delete(self):
req = delete_menu.parse_args(strict=True)
menu = TbMenu.query.filter_by(code=req["id"]).first()
msg = "SUPPORT | B_USER | DELETE_MENU | SUCCESS | USER: {} {} | MENU: {} {} {}".format(
request.current_user.code, request.current_user.name, menu.code, menu.name, menu.path)
operation = TbOperation(operator_code=request.current_user.code, content=msg, category="MENU", type="DELETE")
db.session.add(operation)
logger.info(msg)
try:
db.session.delete(menu)
db.session.commit()
except Exception as e:
pass
finally:
return {}, 200
def post(self):
schema = Schema({
"businessId": And(str),
"interface": [{
"path": And(str, len),
"method": And(str, len),
"name": And(str, len),
"visible": And(bool)
}]
})
req, error = validate_schema(schema, request.json)
if error:
return error, 400
user = request.current_user
biz = TbBusiness.query.filter_by(code=req["businessId"]).first()
if not biz:
return Msg.BUSINESS_NOT_EXIST, 400
inters = []
for i in req["interface"]:
inter = TbInterface.query.filter_by(business_code=biz.code,
path=i["path"],
method=i["method"]).first()
if inter:
# 通过 path 和 method 来确定一个接口，用户就是对这个接口进行修改
inter.name = i["name"]
inter.visible = i["visible"]
else:
interface = TbInterface(
name=i["name"],
path=i["path"],
method=i["method"],
visible=i["visible"],
creator_code=user.code,
business_code=biz.code,
)
biz.interface.append(interface)
db.session.add(interface)
inters.append(interface)
db.session.commit()
for i in inters:
i.code = str(1400000000 + i.id)
msg = "SUPPORT | B_USER | ADD_INTERFACE | SUCCESS | USER: {} {} | INTERFACE: {}".format(
user.code, user.name, [i.name for i in inters])
operation = TbOperation(operator_code=user.code, content=msg, category="INTERFACE", type="ADD")
db.session.add(operation)
db.session.commit()
logger.info(Msg)
return {}, 200
def delete(self):
"""
删除征信配置
"""
self.reqparse.add_argument("interface",
type=str,
required=True,
location=['json', 'args'],
code=1014010001,
desc="接口编号")
self.reqparse.add_argument("operator_id",
type=str,
location=['json', 'args'],
required=True,
code=1014010001,
desc="操作人ID")
raw_args_dict = self.reqparse.parse_args(strict=True)
if not CreditConf.objects(interface=raw_args_dict["interface"],
is_delete=0).count() == 1:
return 1014010004 # 接口编码错误
try:
de_data = CreditConf.objects(interface=raw_args_dict["interface"],
is_delete=0)
de_data.update(set__is_delete=int(1))
msg = self.create_log_msg(operator_id=raw_args_dict["operator_id"],
interface=raw_args_dict["interface"],
data=json.dumps(raw_args_dict,
ensure_ascii=False),
status="SUCCESS")
self.operator_log(operator_id=raw_args_dict["operator_id"],
log_data=msg,
method="DELETE")
logger.info(msg)
return 0
except Exception as e:
msg = self.create_log_msg(operator_id=raw_args_dict["operator_id"],
interface=raw_args_dict["interface"],
data=json.dumps(raw_args_dict,
ensure_ascii=False),
status="FAILED")
self.operator_log(operator_id=raw_args_dict["operator_id"],
log_data=msg,
method="DELETE")
logger.error(msg)
return 1014020001 # 数据格式错误
def get(self):
logger.info("[D] [功能 商户经理面签单审核占比获取]")
req = self.validate_data
logger_req(req)
days = req.get("days") or 30
time_start = utc_timestamp() - (days * 24 * 60 * 60)
time_end = utc_timestamp()
manager = request.current_user
# 面签审核条件
a = TbFaceSignUser.manager_code == manager.code # 商户编码
b = (TbFaceSignUser.update_time >= time_start) # 预约起始起始时间
c = (TbFaceSignUser.update_time <= time_end) # 预约结束时间
d = TbFaceSignUser.status.in_([2, 3, 4]) # 审核总数
e = TbFaceSignUser.status == 3 # 面签成功
e_f = TbFaceSignUser.status == 4
# 扫码量条件
f = LogLoading.manager_id == manager.code
g = LogLoading.load_time >= time_start # 起始时间
h = LogLoading.load_time >= time_start # 结束时间
# 注册量条件
i = LogRegister.manager_id == manager.code
j = LogRegister.reg_time >= time_start
k = LogRegister.reg_time >= time_start
# 面签总数
ke = [a, b, c, d]
all_facesign = TbFaceSignUser.query.filter(*ke).count()
# 面签审核成功
ke_p = [a, b, c, e]
pass_facesign = TbFaceSignUser.query.filter(*ke_p).count()
# 面签审核失败
ke_p = [a, b, c, e_f]
refuse_facesign = TbFaceSignUser.query.filter(*ke_p).count()
# 扫码量
ke_sc = [f, g, h]
scan_code = LogLoading.query.filter(*ke_sc).count()
# 注册量
ke_r = [i, j, k]
register = LogRegister.query.filter(*ke_r).count()
return {
"all_number": all_facesign,
"pass_number": pass_facesign,
"refuse_number": refuse_facesign,
"scan_code_number": scan_code,
"register_number": register
}
def put(self):
req = reset_pwd.parse_args(strict=True)
user = TbUser.query.filter_by(code=req["id"]).first()
if not user:
return Msg.USER_NOT_EXISTS, 400
user.generate_password("123456")
msg = "SUPPORT | B_USER | RESET_PASSWORD | SUCCESS | EDITOR: {} {} | USER: {} {}".format(
request.current_user.code, request.current_user.name, user.code,
user.name)
operation = TbOperation(operator_code=user.code,
content=msg,
category="USER_MANAGE",
type="EDIT")
db.session.add(operation)
db.session.commit()
redis.delete("support_jwt_{}".format(user.code))
logger.info(msg)
return {}, 200
def post(self):
"""
分配审核任务
"""
evt_type = self.validate_data.get("evt_type")
operator = self.validate_data.get("operator")
operator_id = self.validate_data.get("operator_id")
count = self.validate_data.get("count")
queryset = Evt.objects(operator_id=None, evt_type=evt_type)
res_list = queryset.order_by("time")[:count]
for evt in res_list:
evt.operator = operator
evt.operator_id = operator_id
evt.save()
logger.info("已分配审核任务 evt_id:%s , rxt(serial_no):%s , 审核类型:%s , 审核人:%s , 审核人id: %s " %
(evt.id, evt.serial_no, evt.evt_type, evt.operator, evt.operator_id))
logger.info("分配成功数量：%s" % len(res_list))
return {"cnt": len(res_list)}
def post(self):
schema = Schema({
"businessId": And(str),
"menu": [{
"path": And(str, len),
"name": And(str, len),
"visible": And(bool)
}]
})
req, error = validate_schema(schema, request.json)
if error:
return error, 400
biz = TbBusiness.query.filter_by(code=req["businessId"]).first()
if not biz:
return Msg.BUSINESS_NOT_EXIST, 400
menus = []
for i in req["menu"]:
menu = TbMenu.query.filter_by(business_code=biz.code, path=i["path"]).first()
if menu:
# 通过 path 来确定一个菜单，用户就是对这个接口进行修改
menu.name = i["name"]
menu.visible = i["visible"]
else:
menu = TbMenu(
name=i["name"],
path=i["path"],
creator_code=request.current_user.code,
business_code=biz.code,
visible=i["visible"],
)
biz.menu.append(menu)
menus.append(menu)
db.session.add_all(menus)
db.session.commit()
for menu in menus:
menu.code = str(1500000000 + menu.id)
msg = "SUPPORT | B_USER | ADD_MENU | SUCCESS | USER: {} {} | MENU: {}".format(
request.current_user.code, request.current_user.name, [i.name for i in menus])
operation = TbOperation(operator_code=request.current_user.code, content=msg, category="MENU", type="ADD")
db.session.add(operation)
db.session.commit()
logger.info(msg)
return {}, 200
