def post(self, request, args: str = None):
try:
username = request.data['username']
password = request.data['password']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
else:
valite = util.auth(username=username, password=password)
if valite:
user = Account.objects.filter(username=username).first()
if user is not None:
user.set_password(util.workId())
user.save()
payload = jwt_payload_handler(user)
token = jwt_encode_handler(payload)
return Response({'token': token, 'res': '', 'permissions': user.group})
else:
permissions = Account.objects.create_user(
username=username,
password=util.workId(),
is_staff=0,
group='guest')
permissions.save()
token = jwt_encode_handler(jwt_payload_handler(permissions))
return Response({'token': token, 'res': '', 'permissions': 'guest'})
else:
return HttpResponse(status=401)
def commitorder(self, data, tmp, user, type, id):
try:
x = [x.rstrip(';') for x in tmp]
sql = ';'.join(x)
sql = sql.strip(' ').rstrip(';')
workId = util.workId()
SqlOrder.objects.get_or_create(username=user,
date=util.date(),
work_id=workId,
status=2,
basename=data['basename'],
sql=sql,
type=type,
text=data['text'],
backup=data['backup'],
bundle_id=id,
assigned=data['assigned'],
delay=data['delay'])
# 记录转发消息
Usermessage.objects.create(from_user=user,
time=util.date(),
title='工单:' + workId + ' 提交通知',
content=data['text'],
to_user=data['assigned'],
state='unread')
submit_push_messages(workId=workId,
user=user,
addr_ip=addr_ip,
text=data['text'],
assigned=data['assigned'],
id=id).start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def post(self, request, args=None):
try:
data = json.loads(request.data['data'])
tmp = json.loads(request.data['sql'])
user = request.data['user']
type = request.data['type']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
x = [x.rstrip(';') for x in tmp]
sql = ';'.join(x)
sql = sql.strip(' ').rstrip(';')
workId = util.workId()
SqlOrder.objects.get_or_create(
username=user,
date=util.date(),
work_id=workId,
status=2,
basename=data['basename'],
sql=sql,
type=type,
text=data['text'],
backup=data['backup'],
bundle_id=id
)
content = DatabaseList.objects.filter(id=id).first()
if content.url:
util.dingding(content='工单提交通知\n' + content.before, url=content.url)
return Response('已提交，请等待管理员审核！')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def post(self, request, args: str = None):
authgroup_str = (",".join(request.data['auth_group']))
grained_list = json.loads(request.data['grained_list'])
real_name = request.data['real_name']
work_id = util.workId()
applygrained.objects.get_or_create(work_id=work_id,
username=request.user,
permissions=grained_list,
auth_group=authgroup_str,
status=2,
real_name=real_name)
mail = Account.objects.filter(id=1).first()
try:
thread = threading.Thread(target=push_message,
args=({
'to_user': request.user,
'workid': work_id
}, 2, request.user, mail.email, work_id,
'已提交'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
finally:
return Response('权限申请已提交!')
def post(self, request, args=None):
print("post请求")
try:
data = json.loads(request.data['data'])
tmp = json.loads(request.data['sql'])
type = request.data['type']
real_name = request.data['real_name']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
x = [x.rstrip(';') for x in tmp]
if str(x[0]).lstrip().startswith('use'):
del x[0]
sql = ';'.join(x)
sql = sql.strip(' ').rstrip(';')
workId = util.workId()
env_name = Env.objects.filter(id=data['env_id'])[0].env_name
service_name = Service.objects.filter(
id=data['service_id'])[0].service_name
res, err = SqlOrder.objects.get_or_create(
username=request.user,
date=util.date(),
work_id=workId,
status=2,
basename=data['basename'],
sql=sql,
type=type,
text=data['text'],
backup=data['backup'],
bundle_id=id,
assigned=data['assigned'],
delay=data['delay'],
real_name=real_name,
version=data['version'],
env_name=env_name,
env_id=data['env_id'],
service_name=service_name,
service_id=data['service_id'],
)
user_res = Account.objects.filter(username=request.user)[0]
if err and data['env_id'] == 1 and res.bundle_id == 18:
arr = order_push_message(addr_ip, res.id, real_name,
real_name)
threading.Timer(0, arr.run).start()
submit_push_messages(workId=workId,
user=request.user,
addr_ip=addr_ip,
text=data['text'],
assigned=data['assigned'],
id=id).start()
return Response('已提交，请等待管理员审核!')
except Exception as e:
traceback.print_exc()
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def post(self, request, args=None):
try:
print(request.data)
newserviceData = request.data['newserviceData']
data = json.loads(request.data['data'])
uporder = request.data['uporder']
config_properties = request.data['config_properties']
user = request.data['user']
except KeyError as e:
client.captureException()
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
workId = util.workId()
onlineinfo_db.objects.get_or_create(
iteration_name=data['iteration_name'],
date=util.date(),
workid=workId,
env_name=data['env_name'],
project_name=data['project_name'],
upstart_time=data['upstart_time'],
upbak_time=data['upbak_time'],
versionvalue=data['versionvalue'],
newserviceData=newserviceData,
state_em=data['state_em'],
updesc=data['updesc'],
sqlorder=str(data['sqlorder']).replace('\'', '\"'),
uporder=uporder,
addservice=data['addservice'],
config_properties=config_properties,
progress_editor=data['progress_editor'],
remark=data['remark'],
owner=user,
assigned=data['assigned'])
CloudOrder.objects.get_or_create(
date=util.date(),
remark=data['project_name'] + '_' +
env_name_list[data['env_name']] + '_' +
iteration_list[data['iteration_name']],
type=0,
status=3,
username=user,
assigned=data['assigned'],
workid=workId)
submit_push_messages(workId=workId,
user=user,
to_user=data['assigned'],
id=1,
addr_ip=addr_ip,
assigned=data['assigned'],
text='text').run()
return Response({'status': 'success', 'orderid': workId})
except Exception as e:
client.captureException()
return Response({'status': 'error', 'log': '后端保存失败'})
def post(self, request, args: str = None):
grained_list = json.loads(request.data['grained_list'])
work_id = util.workId()
applygrained.objects.get_or_create(work_id=work_id, username=request.user, permissions=grained_list, status=2)
mail = Account.objects.filter(id=1).first()
try:
thread = threading.Thread(target=push_message, args=(
{'to_user': request.user, 'workid': work_id}, 2, request.user, mail.email, work_id, '已提交'))
thread.start()
except:
pass
return Response('权限申请已提交!')
def post(self, request, args=None):
try:
print(request.data)
data = json.loads(request.data['data'])
user = request.data['user']
except KeyError as e:
client.captureException()
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
workId = util.workId()
addnewpcinfo_db.objects.get_or_create(
date=util.date(),
workid=workId,
env_name=data['env_name'],
project_name=data['project_name'],
remark=data['remark'],
owner=user,
os_soft_need=str(data['os_soft_need']).replace('\'', '\"'),
opentime=data['opentime'],
appname=data['appname'],
assigned=data['assigned'],
newpc_type=data['newpc_type'],
servernum=data['servernum'],
cpunum=data['cpunum'],
mem=data['mem'],
OsDiskType=data['OsDiskType'],
OsDiskSize=data['OsDiskSize'],
DataDiskSize=data['DataDiskSize'],
domain=data['domain'],
jdk_version=data['jdk_version'],
jvm_properties=data['jvm_properties'],
netbrand=data['netbrand'],
https_choice=data['https_choice'],
DataDiskType=data['DataDiskType'])
CloudOrder.objects.get_or_create(date=util.date(),
remark=data['remark'],
type=2,
status=3,
username=user,
assigned=data['assigned'],
workid=workId)
submit_push_messages(workId=workId,
user=user,
to_user=data['assigned'],
id=1,
addr_ip=addr_ip,
assigned=data['assigned'],
text='text').run()
return Response('已提交，请等待管理员审核!')
def post(self, request, args: str = None):
grained_list = json.loads(request.data['grained_list'])
work_id = util.workId()
applygrained.objects.get_or_create(work_id=work_id,
username=request.user,
permissions=grained_list,
status=2)
mail = Account.objects.filter(id=1).first()
thread = threading.Thread(target=push_message,
args=({
'to_user': request.user,
'workid': work_id
}, 2, request.user, mail.email, work_id,
'已提交'))
thread.start()
return Response('权限申请已提交!')
def post(self, request, args=None):
try:
data = json.loads(request.data['data'])
tmp = json.loads(request.data['sql'])
user = request.data['user']
source_table = request.data['source_table']
dest_table = request.data['dest_table']
archive_condition = request.data['archive_condition']
soure_dbname = request.data['source_dbname']
dest_dbname = request.data['dest_dbname']
source_id = request.data['source_id']
dest_id = request.data['dest_id']
source_id = request.data['source_id']
status = request.data['status']
type = request.data['type']
ssh_hostid = request.data['ssh_hostid']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
workId = util.workId()
ArchiveLog.objects.get_or_create(
source_id=source_id,
db_source=soure_dbname,
table_source=source_table,
dest_id=dest_id,
db_dest=dest_dbname,
dest_table=dest_table,
date=util.date(),
archive_condition=archive_condition,
status=status,
type=type,
ssh_hostid=ssh_hostid,
)
submit_push_messages(workId=workId,
user=user,
addr_ip=addr_ip,
text=data['text'],
assigned=data['assigned'],
id=id).start()
return Response('已提交!')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def post(self, request, args=None):
try:
data = json.loads(request.data['data'])
tmp = json.loads(request.data['sql'])
type = request.data['type']
real_name = request.data['real_name']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
x = [x.rstrip(';') for x in tmp]
if str(x[0]).lstrip().startswith('use'):
del x[0]
sql = ';'.join(x)
sql = sql.strip(' ').rstrip(';')
workId = util.workId()
SqlOrder.objects.get_or_create(
username=request.user,
date=util.date(),
work_id=workId,
status=2,
basename=data['basename'],
sql=sql,
type=type,
text=data['text'],
backup=data['backup'],
bundle_id=id,
assigned=data['assigned'],
delay=data['delay'],
real_name=real_name
)
submit_push_messages(
workId=workId,
user=request.user,
addr_ip=addr_ip,
text=data['text'],
assigned=data['assigned'],
id=id
).start()
return Response('已提交，请等待管理员审核!')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def post(self, request, args=None):
try:
data = json.loads(request.data['data'])
tmp = json.loads(request.data['sql'])
type = request.data['type']
real_name = request.data['real_name']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
x = [x.rstrip(';') for x in tmp]
if str(x[0]).lstrip().startswith('use'):
del x[0]
sql = ';'.join(x)
sql = sql.strip(' ').rstrip(';')
workId = util.workId()
SqlOrder.objects.get_or_create(
username=request.user,
date=util.date(),
work_id=workId,
status=2,
basename=data['basename'],
sql=sql,
type=type,
text=data['text'],
backup=data['backup'],
bundle_id=id,
assigned=data['assigned'],
delay=data['delay'],
real_name=real_name
)
submit_push_messages(
workId=workId,
user=request.user,
addr_ip=addr_ip,
text=data['text'],
assigned=data['assigned'],
id=id
).start()
return Response('已提交，请等待Leader审核!')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def post(self, request, args=None):
try:
data = json.loads(request.data['data'])
user = request.data['user']
except KeyError as e:
client.captureException()
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
workId = util.workId()
extendinfo_db.objects.get_or_create(
date=util.date(),
workid=workId,
env_name=data['env_name'],
project_name=data['project_name'],
remark=data['remark'],
owner=user,
extend_type=data['extend_type'],
ghost_choice=data['ghost_choice'],
os_soft_need=str(data['os_soft_need']).replace('\'', '\"'),
opentime=data['opentime'],
servernum=data['servernum'],
properties_change=data['properties_change'],
appname=data['appname'],
assigned=data['assigned'])
CloudOrder.objects.get_or_create(date=util.date(),
remark=data['remark'],
type=1,
status=3,
username=user,
assigned=data['assigned'],
workid=workId)
submit_push_messages(workId=workId,
user=user,
to_user=data['assigned'],
id=1,
addr_ip=addr_ip,
assigned=data['assigned'],
text='text').run()
return Response('已提交，请等待管理员审核!')
def post(self, request, args: str = None):
authgroup_str = (",".join(request.data['auth_group']))
grained_list = json.loads(request.data['grained_list'])
real_name = request.data['real_name']
work_id = util.workId()
applygrained.objects.get_or_create(
work_id=work_id,
username=request.user,
permissions=grained_list,
auth_group=authgroup_str,
status=2,
real_name=real_name)
mail = Account.objects.filter(id=1).first()
try:
thread = threading.Thread(target=push_message, args=(
{'to_user': request.user, 'workid': work_id}, 2, request.user, mail.email, work_id, '已提交'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
finally:
return Response('权限申请已提交!')
def put(self, request, args: str = None):
if request.data['mode'] == 'put':
instructions = request.data['instructions']
connection_name = request.data['connection_name']
computer_room = request.data['computer_room']
timer = int(request.data['timer'])
export = request.data['export']
audit = request.data['audit']
un_init = util.init_conf()
query_switch = ast.literal_eval(un_init['other'])
query_per = 2
work_id = util.workId()
if not query_switch['query']:
query_per = 1
userinfo = Account.objects.filter(username=audit,
group='admin').first()
thread = threading.Thread(target=push_message,
args=({
'to_user': request.user,
'workid': work_id
}, 5, request.user, userinfo.email,
work_id, '提交'))
thread.start()
query_order.objects.create(work_id=work_id,
instructions=instructions,
username=request.user,
timer=timer,
date=util.date(),
query_per=query_per,
connection_name=connection_name,
computer_room=computer_room,
export=export,
audit=audit,
time=util.date())
if not query_switch['query']:
t = threading.Thread(target=query_worklf.query_callback,
args=(timer, work_id))
t.start()
## 钉钉及email站内信推送
return Response('查询工单已提交，等待管理员审核！')
elif request.data['mode'] == 'agree':
work_id = request.data['work_id']
query_info = query_order.objects.filter(
work_id=work_id).order_by('-id').first()
t = threading.Thread(target=query_worklf.query_callback,
args=(query_info.timer, work_id))
t.start()
userinfo = Account.objects.filter(
username=query_info.username).first()
thread = threading.Thread(target=push_message,
args=({
'to_user': query_info.username,
'workid': query_info.work_id
}, 6, query_info.username,
userinfo.email, work_id, '同意'))
thread.start()
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'disagree':
work_id = request.data['work_id']
query_order.objects.filter(work_id=work_id).update(query_per=0)
query_info = query_order.objects.filter(
work_id=work_id).order_by('-id').first()
userinfo = Account.objects.filter(
username=query_info.username).first()
thread = threading.Thread(target=push_message,
args=({
'to_user': query_info.username,
'workid': query_info.work_id
}, 7, query_info.username,
userinfo.email, work_id, '驳回'))
thread.start()
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'status':
try:
status = query_order.objects.filter(
username=request.user).order_by('-id').first()
return Response(status.query_per)
except:
return Response(0)
elif request.data['mode'] == 'end':
try:
query_order.objects.filter(
username=request.user).order_by('-id').update(query_per=3)
return Response('结束查询工单成功！')
except Exception as e:
return Response(e)
elif request.data['mode'] == 'info':
tablelist = []
database = query_order.objects.filter(
username=request.user).order_by('-id').first()
_connection = DatabaseList.objects.filter(
connection_name=database.connection_name).first()
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port) as f:
dataname = f.query_info(sql='show databases')
children = []
ignore = [
'information_schema', 'sys', 'performance_schema', 'mysql'
]
for index, uc in enumerate(dataname):
for cc in ignore:
if uc['Database'] == cc:
del dataname[index]
index = index - 1
for i in dataname:
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port,
db=i['Database']) as f:
tablename = f.query_info(sql='show tables')
for c in tablename:
key = 'Tables_in_%s' % i['Database']
children.append({'title': c[key]})
tablelist.append({
'title': i['Database'],
'children': children
})
children = []
data = [{
'title': database.connection_name,
'expand': 'true',
'children': tablelist
}]
return Response({
'info': json.dumps(data),
'status': database.export
})
def put(self, request, args: str = None):
if request.data['mode'] == 'put':
instructions = request.data['instructions']
connection_name = request.data['connection_name']
computer_room = request.data['computer_room']
timer = int(request.data['timer'])
export = request.data['export']
audit = request.data['audit']
un_init = util.init_conf()
query_switch = ast.literal_eval(un_init['other'])
query_per = 2
work_id = util.workId()
if not query_switch['query']:
query_per = 1
userinfo = Account.objects.filter(username=audit, group='admin').first()
thread = threading.Thread(
target=push_message,
args=({'to_user': request.user, 'workid': work_id}, 5, request.user, userinfo.email, work_id, '提交')
)
thread.start()
query_order.objects.create(
work_id=work_id,
instructions=instructions,
username=request.user,
timer=timer,
date=util.date(),
query_per=query_per,
connection_name=connection_name,
computer_room=computer_room,
export=export,
audit=audit,
time=util.date()
)
if not query_switch['query']:
t = threading.Thread(target=query_worklf.query_callback, args=(timer, work_id))
t.start()
## 钉钉及email站内信推送
return Response('查询工单已提交，等待管理员审核！')
elif request.data['mode'] == 'agree':
work_id = request.data['work_id']
query_info = query_order.objects.filter(work_id=work_id).order_by('-id').first()
t = threading.Thread(target=query_worklf.query_callback, args=(query_info.timer, work_id))
t.start()
userinfo = Account.objects.filter(username=query_info.username).first()
thread = threading.Thread(target=push_message, args=(
{'to_user': query_info.username, 'workid': query_info.work_id}, 6, query_info.username, userinfo.email,
work_id, '同意'))
thread.start()
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'disagree':
work_id = request.data['work_id']
query_order.objects.filter(work_id=work_id).update(query_per=0)
query_info = query_order.objects.filter(work_id=work_id).order_by('-id').first()
userinfo = Account.objects.filter(username=query_info.username).first()
thread = threading.Thread(target=push_message, args=(
{'to_user': query_info.username, 'workid': query_info.work_id}, 7, query_info.username, userinfo.email,
work_id, '驳回'))
thread.start()
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'status':
try:
status = query_order.objects.filter(username=request.user).order_by('-id').first()
return Response(status.query_per)
except:
return Response(0)
elif request.data['mode'] == 'end':
try:
query_order.objects.filter(username=request.user).order_by('-id').update(query_per=3)
return Response('结束查询工单成功！')
except Exception as e:
return Response(e)
elif request.data['mode'] == 'info':
tablelist = []
database = query_order.objects.filter(username=request.user).order_by('-id').first()
_connection = DatabaseList.objects.filter(connection_name=database.connection_name).first()
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port) as f:
dataname = f.query_info(sql='show databases')
children = []
ignore = ['information_schema', 'sys', 'performance_schema', 'mysql']
for index, uc in enumerate(dataname):
for cc in ignore:
if uc['Database'] == cc:
del dataname[index]
index = index - 1
for i in dataname:
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port,
db=i['Database']) as f:
tablename = f.query_info(sql='show tables')
for c in tablename:
key = 'Tables_in_%s' % i['Database']
children.append({
'title': c[key]
})
tablelist.append({
'title': i['Database'],
'children': children
})
children = []
data = [{
'title': database.connection_name,
'expand': 'true',
'children': tablelist
}]
return Response({'info': json.dumps(data), 'status': database.export})
def put(self, request, args: str = None):
if request.data['mode'] == 'put':
instructions = request.data['instructions']
connection_name = request.data['connection_name']
computer_room = request.data['computer_room']
real = request.data['real_name']
export = request.data['export']
audit = request.data['audit']
un_init = util.init_conf()
query_switch = ast.literal_eval(un_init['other'])
query_per = 2
work_id = util.workId()
if not query_switch['query']:
query_per = 2
else:
userinfo = Account.objects.filter(username=audit,
group='admin').first()
try:
thread = threading.Thread(target=push_message,
args=({
'to_user': request.user,
'workid': work_id
}, 5, request.user,
userinfo.email, work_id,
'提交'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
query_order.objects.create(work_id=work_id,
instructions=instructions,
username=request.user,
date=util.date(),
query_per=query_per,
connection_name=connection_name,
computer_room=computer_room,
export=export,
audit=audit,
time=util.date(),
real_name=real)
if not query_switch['query']:
query_order.objects.filter(work_id=work_id).update(query_per=1)
## 钉钉及email站内信推送
return Response('查询工单已提交，等待管理员审核！')
elif request.data['mode'] == 'agree':
work_id = request.data['work_id']
query_info = query_order.objects.filter(
work_id=work_id).order_by('-id').first()
query_order.objects.filter(work_id=work_id).update(query_per=1)
userinfo = Account.objects.filter(
username=query_info.username).first()
try:
thread = threading.Thread(target=push_message,
args=({
'to_user': query_info.username,
'workid': query_info.work_id
}, 6, query_info.username,
userinfo.email, work_id, '同意'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'disagree':
work_id = request.data['work_id']
query_order.objects.filter(work_id=work_id).update(query_per=0)
query_info = query_order.objects.filter(
work_id=work_id).order_by('-id').first()
userinfo = Account.objects.filter(
username=query_info.username).first()
try:
thread = threading.Thread(target=push_message,
args=({
'to_user': query_info.username,
'workid': query_info.work_id
}, 7, query_info.username,
userinfo.email, work_id, '驳回'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'status':
try:
status = query_order.objects.filter(
username=request.user).order_by('-id').first()
return Response(status.query_per)
except:
return Response(0)
elif request.data['mode'] == 'end':
try:
query_order.objects.filter(
username=request.data['username']).order_by('-id').update(
query_per=3)
return Response('已结束查询！')
except Exception as e:
return HttpResponse(e)
elif request.data['mode'] == 'info':
tablelist = []
highlist = []
database = query_order.objects.filter(
username=request.user).order_by('-id').first()
_connection = DatabaseList.objects.filter(
connection_name=database.connection_name).first()
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port) as f:
dataname = f.query_info(sql='show databases')
children = []
ignore = exclued_db_list()
for index, uc in sorted(enumerate(dataname), reverse=True):
for cc in ignore:
if uc['Database'] == cc:
del dataname[index]
for i in dataname:
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port,
db=i['Database']) as f:
tablename = f.query_info(sql='show tables')
highlist.append({'vl': i['Database'], 'meta': '库名'})
for c in tablename:
key = 'Tables_in_%s' % i['Database']
highlist.append({'vl': c[key], 'meta': '表名'})
children.append({'title': c[key]})
tablelist.append({
'title': i['Database'],
'children': children
})
children = []
data = [{
'title': database.connection_name,
'expand': 'true',
'children': tablelist
}]
return Response({
'info': json.dumps(data),
'status': database.export,
'highlight': highlist
})
def post(self, request, args=None):
try:
data = json.loads(request.data['data'])
tmp = json.loads(request.data['sql'])
user = request.data['user']
type = request.data['type']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
x = [x.rstrip(';') for x in tmp]
sql = ';'.join(x)
sql = sql.strip(' ').rstrip(';')
workId = util.workId()
SqlOrder.objects.get_or_create(username=user,
date=util.date(),
work_id=workId,
status=2,
basename=data['basename'],
sql=sql,
type=type,
text=data['text'],
backup=data['backup'],
bundle_id=id,
assigned=data['assigned'])
content = DatabaseList.objects.filter(id=id).first()
mail = Account.objects.filter(
username=data['assigned']).first()
tag = globalpermissions.objects.filter(
authorization='global').first()
ret_info = '已提交，请等待管理员审核!'
if tag is None or tag.dingding == 0:
pass
else:
if content.url:
try:
util.dingding(
content=
'工单提交通知\n工单编号:%s\n发起人:%s\n地址:%s\n工单说明:%s\n状态:已提交\n备注:%s'
% (workId, user, addr_ip, data['text'],
content.before),
url=content.url)
except:
ret_info = '工单执行成功!但是钉钉推送失败,请查看错误日志排查错误.'
if tag is None or tag.email == 0:
pass
else:
if mail.email:
mess_info = {
'workid': workId,
'to_user': user,
'addr': addr_ip,
'text': data['text'],
'note': content.before
}
try:
put_mess = send_email.send_email(
to_addr=mail.email)
put_mess.send_mail(mail_data=mess_info, type=2)
except:
ret_info = '工单执行成功!但是邮箱推送失败,请查看错误日志排查错误.'
return Response(ret_info)
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def put(self, request, args: str = None):
if request.data['mode'] == 'put':
instructions = request.data['instructions']
connection_name = request.data['connection_name']
computer_room = request.data['computer_room']
real = request.data['real_name']
export = request.data['export']
audit = request.data['audit']
un_init = util.init_conf()
query_switch = ast.literal_eval(un_init['other'])
query_per = 2
work_id = util.workId()
if not query_switch['query']:
query_per = 2
else:
userinfo = Account.objects.filter(username=audit, group='admin').first()
try:
thread = threading.Thread(
target=push_message,
args=(
{'to_user': request.user, 'workid': work_id}, 5, request.user, userinfo.email, work_id,
'提交')
)
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
query_order.objects.create(
work_id=work_id,
instructions=instructions,
username=request.user,
date=util.date(),
query_per=query_per,
connection_name=connection_name,
computer_room=computer_room,
export=export,
audit=audit,
time=util.date(),
real_name=real
)
if not query_switch['query']:
query_order.objects.filter(work_id=work_id).update(query_per=1)
## 钉钉及email站内信推送
return Response('查询工单已提交，等待管理员审核！')
elif request.data['mode'] == 'agree':
work_id = request.data['work_id']
query_info = query_order.objects.filter(work_id=work_id).order_by('-id').first()
query_order.objects.filter(work_id=work_id).update(query_per=1)
userinfo = Account.objects.filter(username=query_info.username).first()
try:
thread = threading.Thread(target=push_message, args=(
{'to_user': query_info.username, 'workid': query_info.work_id}, 6, query_info.username,
userinfo.email,
work_id, '同意'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'disagree':
work_id = request.data['work_id']
query_order.objects.filter(work_id=work_id).update(query_per=0)
query_info = query_order.objects.filter(work_id=work_id).order_by('-id').first()
userinfo = Account.objects.filter(username=query_info.username).first()
try:
thread = threading.Thread(target=push_message, args=(
{'to_user': query_info.username, 'workid': query_info.work_id}, 7, query_info.username,
userinfo.email,
work_id, '驳回'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'status':
try:
status = query_order.objects.filter(username=request.user).order_by('-id').first()
return Response(status.query_per)
except:
return Response(0)
elif request.data['mode'] == 'end':
try:
query_order.objects.filter(username=request.data['username']).order_by('-id').update(query_per=3)
return Response('已结束查询！')
except Exception as e:
return HttpResponse(e)
elif request.data['mode'] == 'info':
tablelist = []
highlist = []
database = query_order.objects.filter(username=request.user).order_by('-id').first()
_connection = DatabaseList.objects.filter(connection_name=database.connection_name).first()
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port) as f:
dataname = f.query_info(sql='show databases')
children = []
ignore = exclued_db_list()
for index, uc in sorted(enumerate(dataname), reverse=True):
for cc in ignore:
if uc['Database'] == cc:
del dataname[index]
for i in dataname:
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port,
db=i['Database']) as f:
tablename = f.query_info(sql='show tables')
highlist.append({'vl': i['Database'], 'meta': '库名'})
for c in tablename:
key = 'Tables_in_%s' % i['Database']
highlist.append({'vl': c[key], 'meta': '表名'})
children.append({
'title': c[key]
})
tablelist.append({
'title': i['Database'],
'children': children
})
children = []
data = [{
'title': database.connection_name,
'expand': 'true',
'children': tablelist
}]
return Response({'info': json.dumps(data), 'status': database.export, 'highlight': highlist})
def put(self, request, args: str = None):
if request.data['mode'] == 'put':
instructions = request.data['instructions']
connection_name = request.data['connection_name']
computer_room = request.data['computer_room']
timer = int(request.data['timer'])
export = request.data['export']
audit = request.data['audit']
un_init = util.init_conf()
query_switch = ast.literal_eval(un_init['other'])
query_per = 2
work_id = util.workId()
if not query_switch['query']:
query_per = 1
else:
userinfo = Account.objects.filter(username=audit,
group='admin').first()
try:
thread = threading.Thread(target=push_message,
args=({
'to_user': request.user,
'workid': work_id
}, 5, request.user,
userinfo.email, work_id,
'提交'))
thread.start()
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
# 最大可申请7天权限
timer = 168 if timer > 168 else timer
query_order.objects.create(
work_id=work_id,
instructions=instructions,
username=request.user,
timer=timer,
date=datetime.datetime.now() + datetime.timedelta(hours=timer),
query_per=query_per,
connection_name=','.join(connection_name),
computer_room=computer_room,
export=export,
audit=audit,
time=util.datetime())
if not query_switch['query']:
t = threading.Thread(target=query_worklf.query_callback,
args=(timer, work_id))
t.start()
## 钉钉及email站内信推送
return Response('查询工单已提交，等待管理员审核！')
elif request.data['mode'] == 'agree':
work_id = request.data['work_id']
query_info = query_order.objects.filter(
work_id=work_id).order_by('-id').first()
t = threading.Thread(target=query_worklf.query_callback,
args=(query_info.timer, work_id))
t.start()
userinfo = Account.objects.filter(
username=query_info.username).first()
thread = threading.Thread(target=push_message,
args=({
'to_user': query_info.username,
'workid': query_info.work_id
}, 6, query_info.username,
userinfo.email, work_id, '同意'))
thread.start()
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'disagree':
work_id = request.data['work_id']
query_order.objects.filter(work_id=work_id).update(query_per=0)
query_info = query_order.objects.filter(
work_id=work_id).order_by('-id').first()
userinfo = Account.objects.filter(
username=query_info.username).first()
thread = threading.Thread(target=push_message,
args=({
'to_user': query_info.username,
'workid': query_info.work_id
}, 7, query_info.username,
userinfo.email, work_id, '驳回'))
thread.start()
return Response('查询工单状态已更新！')
elif request.data['mode'] == 'status':
try:
limit = util.get_conf_limit()
curr_time = util.datetime()
status = query_order.objects.filter(
username=request.user).filter(query_per=1).filter(
date__gt=curr_time).aggregate(count=Count('id'))
if status['count'] > 0:
return Response({'limit': limit, 'status': 1})
else:
return Response({'limit': limit, 'status': 0})
except:
return Response(0)
elif request.data['mode'] == 'end':
try:
query_order.objects.filter(
username=request.user).order_by('-id').update(query_per=3)
return Response('结束查询工单成功！')
except Exception as e:
return Response(e)
elif request.data['mode'] == 'dblist':
dbname_list = get_dblist_foruser(request.user)
return Response(dbname_list)
elif request.data['mode'] == 'tablist':
dbname = request.data['dbname']
_connection = DatabaseList.objects.filter(
connection_name=dbname).first()
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port,
db=_connection.dbname) as f:
tabname = f.query_info(sql='show tables')
return Response([list(i.values())[0] for i in tabname])
elif request.data['mode'] == 'tabmeta':
dbname = request.data['dbname']
tabname = request.data['tabname']
get_tabmeta_sql = ("show create table {0}".format(tabname))
_connection = DatabaseList.objects.filter(
connection_name=dbname).first()
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port,
db=_connection.dbname) as f:
tabmeta = f.query_info(sql=get_tabmeta_sql)
try:
tabmeta_deal = tabmeta[0]["Create Table"]
return Response(tabmeta_deal)
except Exception:
return Response('')
elif request.data['mode'] == 'addcollect':
try:
user_collect.objects.create(
username=request.user,
connect_name=request.data["conn_name"],
sql_text=request.data["sql_text"],
collect_alias=request.data["alias_name"],
create_time=util.datetime(),
update_time=util.datetime())
return Response('ok')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif request.data['mode'] == 'getcollect':
try:
my_collect = user_collect.objects.filter(
username=request.user).order_by("-sort_flag").order_by(
"-update_time")
data_dict = [
{
'title': "别名",
"key": "collect_alias",
"fixed": "left",
"sortable": "true",
"width": 150
},
{
'title': "连接名",
"key": "connect_name",
"fixed": "left",
"sortable": "true",
"width": 150
},
{
'title': "sql",
"key": "sql_text",
"fixed": "left",
"sortable": "true",
"width": 265
},
]
data_result = []
len = 0
for i in my_collect:
len = len + 1
data_result.append({
"id": i.id,
"collect_alias": i.collect_alias,
"connect_name": i.connect_name,
"sql_text": i.sql_text
})
collect_fin = {
'data': data_result,
'title': data_dict,
'len': len
}
return HttpResponse(
simplejson.dumps(collect_fin,
cls=DateEncoder,
bigint_as_string=True))
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif request.data['mode'] == 'delcollect':
try:
user_collect.objects.filter(id=request.data["id"]).delete()
return Response('ok')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif request.data['mode'] == 'setcollecttop':
try:
user_collect.objects.filter(id=request.data["id"]).update(
sort_flag=999, update_time=util.datetime())
return Response('ok')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif request.data['mode'] == 'info':
tablelist = []
database_list_from_db = query_order.objects.filter(
username=request.user).filter(query_per=1)
database_list = []
dbname_list = []
for row in database_list_from_db:
for i in row.connection_name.split(","):
if i not in dbname_list:
dbname_list.append(i)
database_list.append({
"connection_name": i,
"export": row.export
})
data = []
for database in database_list:
_connection = DatabaseList.objects.filter(
connection_name=database["connection_name"]).first()
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port) as f:
dataname = f.query_info(sql='show databases')
children = []
ignore = [
'information_schema', 'sys', 'performance_schema', 'mysql'
]
for index, uc in enumerate(dataname):
for cc in ignore:
if uc['Database'] == cc:
del dataname[index]
index = index - 1
for i in dataname:
with con_database.SQLgo(ip=_connection.ip,
user=_connection.username,
password=_connection.password,
port=_connection.port,
db=i['Database']) as f:
tablename = f.query_info(sql='show tables')
for c in tablename:
key = 'Tables_in_%s' % i['Database']
children.append({'title': c[key]})
tablelist.append({
'title': i['Database'],
'children': children
})
children = []
data.append({
'title': database,
'expand': 'true',
'children': tablelist
})
return Response({
'info': json.dumps(data),
'status': database["export"]
})
