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 put(self, request, args=None):
try:
type = request.data['type']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
else:
if type == 0:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
text = request.data['text']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=id).update(status=0)
_tmpData = SqlOrder.objects.filter(id=id).values(
'work_id',
'bundle_id'
).first()
title = '工单:' + _tmpData['work_id'] + '驳回通知'
Usermessage.objects.get_or_create(
from_user=from_user,
time=util.date(),
title=title,
content=text,
to_user=to_user,
state='unread'
)
rejected_push_messages(_tmpData, to_user, addr_ip, text).start()
return Response('操作成功，该请求已驳回！')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif type == 1:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=id).update(status=3)
order_push_message(addr_ip, id, from_user, to_user).start()
return Response('工单执行成功!请通过记录页面查看具体执行结果')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif type == 'test':
try:
base = request.data['base']
id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
sql = SqlOrder.objects.filter(id=id).first()
data = DatabaseList.objects.filter(id=sql.bundle_id).first()
info = {
'host': data.ip,
'user': data.username,
'password': data.password,
'db': base,
'port': data.port
}
try:
with call_inception.Inception(LoginDic=info) as test:
res = test.Check(sql=sql.sql)
return Response({'result': res, 'status': 200})
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response({'status': '500'})
def put(self, request, args: str = None):
'''
:argument 工单确认执行,驳回,二次检测接口。
:param category 根据获得的category值执行具体的操作逻辑
:return 提交结果信息
'''
try:
category = request.data['type']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
else:
if category == 0:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
text = request.data['text']
workid = request.data['workid']
print(request.data)
except KeyError as e:
print(e)
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
CloudOrder.objects.filter(workid=workid).update(
status=1)
_tmpData = CloudOrder.objects.filter(
workid=workid).values('workid', 'username',
'assigned').first()
title = '工单:' + _tmpData['workid'] + '驳回通知'
Usermessage.objects.get_or_create(from_user=from_user,
time=util.date(),
title=title,
content=text,
to_user=to_user,
state='unread')
print('e')
rejected_push_messages(_tmpData, to_user, from_user,
addr_ip, text).start()
return Response('操作成功，该请求已驳回！')
except Exception as e:
print(e)
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 1:
try:
from_user = request.data['from_user']
workid = request.data['workid']
to_user = '******'
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
CloudOrder.objects.filter(workid=workid).update(
status=2)
order_push_message(addr_ip, workid, from_user,
to_user).run()
return Response('管理员已同意执行工单，请联系管理员查看具体进度')
except Exception as e:
print(e)
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 6:
try:
from_user = request.data['from_user']
workid = request.data['workid']
to_user = '******'
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
CloudOrder.objects.filter(workid=workid).update(
status=6)
order_result_message(addr_ip, workid, from_user,
to_user).run()
return Response('管理员已执行完成工单')
except Exception as e:
print(e)
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
def put(self, request, args: str = None):
'''
:argument 工单确认执行,驳回,二次检测接口。
:param category 根据获得的category值执行具体的操作逻辑
:return 提交结果信息
'''
try:
category = request.data['type']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
else:
if category == 0:
try:
to_user = request.data['to_user']
text = request.data['text']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=order_id).update(
status=0, rejected=text)
_tmpData = SqlOrder.objects.filter(id=order_id).values(
'work_id', 'bundle_id').first()
reject = rejected_push_messages(
_tmpData, to_user, addr_ip, text, request.user)
threading.Timer(0, reject.execute).start()
return Response('操作成功，该请求已驳回！')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 1:
try:
from_user = request.user
to_user = request.data['to_user']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
idempotent = SqlOrder.objects.filter(
id=order_id).first()
if idempotent.status != 2:
return Response('非法传参，触发幂等操作')
else:
delay = 0
if str(idempotent.delay).rstrip() != '':
now_time = datetime.datetime.now()
next_time = datetime.datetime.strptime(
idempotent.delay, "%Y-%m-%d %H:%M")
if now_time > next_time:
return Response('工单定时执行时间不得小于当前时间！！！')
delay = int(
(next_time - now_time).total_seconds())
SqlOrder.objects.filter(id=order_id).update(
status=3)
arr = order_push_message(addr_ip, order_id,
from_user, to_user)
threading.Timer(delay, arr.run).start()
return Response('工单执行成功!请通过记录页面查看具体执行结果')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 2:
try:
perform = request.data['perform']
work_id = request.data['work_id']
username = request.data['username']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
mail = Account.objects.filter(username=perform).first()
SqlOrder.objects.filter(work_id=work_id).update(
executor=perform)
threading.Thread(target=push_message,
args=({
'to_user': username,
'workid': work_id,
'addr': addr_ip
}, 9, request.user, mail.email, work_id,
'已提交执行人')).start()
return Response('工单已提交执行人！')
elif category == 'test':
try:
base = request.data['base']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
sql = SqlOrder.objects.filter(id=order_id).first()
if not sql.sql:
return Response({'status': '工单内无sql语句!'})
data = DatabaseList.objects.filter(
id=sql.bundle_id).first()
info = {
'host': data.ip,
'user': data.username,
'password': data.password,
'db': base,
'port': data.port
}
try:
with call_inception.Inception(LoginDic=info) as test:
res = test.Check(sql=sql.sql)
return Response({'result': res, 'status': 200})
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response({'status': '请检查inception信息是否正确!'})
def put(self, request, args: str = None):
'''
:argument 工单确认执行,驳回,二次检测接口。
:param category 根据获得的category值执行具体的操作逻辑
:return 提交结果信息
'''
try:
category = request.data['type']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
else:
if category == 0:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
text = request.data['text']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=order_id).update(status=0)
_tmpData = SqlOrder.objects.filter(id=order_id).values(
'work_id', 'bundle_id').first()
title = '工单:' + _tmpData['work_id'] + '驳回通知'
Usermessage.objects.get_or_create(from_user=from_user,
time=util.date(),
title=title,
content=text,
to_user=to_user,
state='unread')
rejected_push_messages(_tmpData, to_user, addr_ip,
text).start()
return Response('操作成功，该请求已驳回！')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 1:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=order_id).update(status=3)
order_push_message(addr_ip, order_id, from_user,
to_user).start()
return Response('工单执行成功!请通过记录页面查看具体执行结果')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 2:
try:
perform = request.data['perform']
work_id = request.data['work_id']
username = request.data['username']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
mail = Account.objects.filter(username=username).first()
SqlOrder.objects.filter(work_id=work_id).update(
assigned=perform)
threading.Thread(target=push_message,
args=({
'to_user': request.user,
'workid': work_id
}, 2, request.user, mail.email, work_id,
'已同意')).start()
return Response('工单已提交执行人！')
elif category == 'test':
try:
base = request.data['base']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
sql = SqlOrder.objects.filter(id=order_id).first()
if not sql.sql:
return Response({'status': '工单内无sql语句!'})
data = DatabaseList.objects.filter(
id=sql.bundle_id).first()
info = {
'host': data.ip,
'user': data.username,
'password': data.password,
'db': base,
'port': data.port
}
try:
with call_inception.Inception(LoginDic=info) as test:
res = test.Check(sql=sql.sql)
return Response({'result': res, 'status': 200})
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response({'status': '请检查inception信息是否正确!'})
def put(self, request, args: str = None):
'''
:argument 工单确认执行,驳回,二次检测接口。
:param category 根据获得的category值执行具体的操作逻辑
:return 提交结果信息
'''
try:
category = request.data['type']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
else:
if category == 0:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
text = request.data['text']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=order_id).update(status=0)
_tmpData = SqlOrder.objects.filter(id=order_id).values(
'work_id',
'bundle_id'
).first()
title = '工单:' + _tmpData['work_id'] + '驳回通知'
Usermessage.objects.get_or_create(
from_user=from_user,
time=util.date(),
title=title,
content=text,
to_user=to_user,
state='unread'
)
rejected_push_messages(_tmpData, to_user, addr_ip, text).start()
return Response('操作成功，该请求已驳回！')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 1:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=order_id).update(status=3)
order_push_message(addr_ip, order_id, from_user, to_user).start()
return Response('工单执行成功!请通过记录页面查看具体执行结果')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 2:
try:
perform = request.data['perform']
work_id = request.data['work_id']
username = request.data['username']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
mail = Account.objects.filter(username=perform).first()
SqlOrder.objects.filter(work_id=work_id).update(assigned=perform)
threading.Thread(target=push_message, args=(
{'to_user': username, 'workid': work_id, 'addr': addr_ip}, 9, request.user, mail.email,
work_id,
'已提交执行人')).start()
return Response('工单已提交执行人！')
elif category == 'test':
try:
base = request.data['base']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
sql = SqlOrder.objects.filter(id=order_id).first()
if not sql.sql:
return Response({'status': '工单内无sql语句!'})
data = DatabaseList.objects.filter(id=sql.bundle_id).first()
info = {
'host': data.ip,
'user': data.username,
'password': data.password,
'db': base,
'port': data.port
}
try:
with call_inception.Inception(LoginDic=info) as test:
res = test.Check(sql=sql.sql)
return Response({'result': res, 'status': 200})
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response({'status': '请检查inception信息是否正确!'})
def put(self, request, args: str=None):
'''
:argument 工单确认执行,驳回,二次检测接口。
:param category 根据获得的category值执行具体的操作逻辑
:return 提交结果信息
'''
try:
category = request.data['type']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
else:
DJANGO_INFO.info(request.data)
if category == 0:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
text = request.data['text']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
SqlOrder.objects.filter(id=order_id).update(status=0)
_tmpData = SqlOrder.objects.filter(id=order_id).values(
'work_id',
'bundle_id'
).first()
title = '工单:' + _tmpData['work_id'] + '驳回通知'
Usermessage.objects.get_or_create(
from_user=from_user,
time=util.date(),
title=title,
content=text,
to_user=to_user,
state='unread'
)
rejected_push_messages(_tmpData, to_user, addr_ip, text).start()
return Response('操作成功，该请求已驳回！')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 1:
try:
from_user = request.data['from_user']
to_user = request.data['to_user']
order_id = request.data['id']
audit_id = request.data['audit']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
try:
DJANGO_INFO.info(f'{addr_ip}, {order_id}, {from_user}, {to_user}')
'''audit'''
if audit_id == 1:
SqlOrder.objects.filter(id=order_id).filter(username=from_user).update(status=3)
order_push_message(addr_ip, order_id, from_user, to_user).start()
return Response('工单执行成功!请通过记录页面查看具体执行结果')
else:
SqlOrder.objects.filter(id=order_id).filter(assigned=from_user).update(status=3)
return Response('工单审批成功!请通过记录页面查看具体审批结果')
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
elif category == 'test':
try:
base = request.data['base']
order_id = request.data['id']
except KeyError as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return HttpResponse(status=500)
else:
sql = SqlOrder.objects.filter(id=order_id).first()
data = DatabaseList.objects.filter(id=sql.bundle_id).first()
info = {
'host': data.ip,
'user': data.username,
'password': data.password,
'db': base,
'port': data.port
}
try:
with call_inception.Inception(LoginDic=info) as test:
res = test.Check(sql=sql.sql)
return Response({'result': res, 'status': 200})
except Exception as e:
CUSTOM_ERROR.error(f'{e.__class__.__name__}: {e}')
return Response({'status': '500'})
