def api_webhook_retry():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
webhook_id = RequestUtil.get_parameter('webhook_id', '')
data = {
'src': 'Manually executed'
}
webhook = WebHook.query.get(webhook_id)
if not webhook:
return ResponseUtil.standard_response(0, 'WebHooknot exist!')
if not AuthUtil.has_readonly_auth(user_id, webhook_id):
return ResponseUtil.standard_response(0, 'Permission deny!')
# if webhook.status not in ['3', '4', '5']:
# return ResponseUtil.standard_response(0, 'Webhook is Executing!')
history = History(webhook_id=webhook.id,
data=JsonUtil.object_2_json(data))
history.updateStatus('1')
# status is waiting
webhook.updateStatus('1')
# do the async task
tasks.do_webhook_shell.delay(webhook.id, history.id, data, user_id=user_id)
return ResponseUtil.standard_response(1, webhook.dict())
def add_redis():
host = RequestUtil.get_parameter('host', '')
port = RequestUtil.get_parameter('port', '6379')
password = RequestUtil.get_parameter('password', '')
try:
rst = RedisMonitor().ping(host=host, port=port, password=password)
if not rst.get('success', ''):
# ping 失败
return JsonUtil.object_2_json(rst)
except:
ResponseUtil.standard_response(0, 'Ping error!')
# ping 通，添加
md5 = StringUtil.md5(host + str(port))
redis_info = RedisInfo.query.get(md5)
if redis_info:
redis_info.password = password
else:
redis_info = RedisInfo(md5=md5,
host=host,
port=port,
password=password)
redis_info.save()
return ResponseUtil.standard_response(1, redis_info.dict())
def api_server_new():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
ip = RequestUtil.get_parameter('ip', '')
name = RequestUtil.get_parameter('name', ip)
name = name and name or ip
port = RequestUtil.get_parameter('port', 22)
account = RequestUtil.get_parameter('account', '')
pkey = RequestUtil.get_parameter('pkey', '')
if not all((ip, name, port, account, pkey)):
return ResponseUtil.standard_response(0, 'Form data can not be blank!')
try:
success, log = SshUtil.do_ssh_cmd(ip,
port,
account,
pkey,
'ls -lh',
timeout=5)
if success:
server = Server(ip=ip,
port=port,
account=account,
pkey=pkey,
user_id=user_id,
name=name)
server.save()
return ResponseUtil.standard_response(1, server.dict())
except Exception, e:
print e
def redis_info():
md5 = RequestUtil.get_parameter('md5', '')
redis_info = RedisInfo.query.get(md5)
if redis_info:
return ResponseUtil.standard_response(1, redis_info.dict())
return ResponseUtil.standard_response(0, 'Not Found!')
def api_history_list():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
webhook_id = RequestUtil.get_parameter('webhook_id', '')
if not AuthUtil.has_readonly_auth(user_id, webhook_id):
return ResponseUtil.standard_response(0, 'Permission deny!')
page = RequestUtil.get_parameter('page', '1')
try:
page = int(page)
if page < 1:
page = 1
except:
page = 1
page_size = 25
paginations = History.query\
.filter_by(webhook_id=webhook_id)\
.order_by(History.id.desc())\
.paginate(page, page_size, error_out=False)
histories = [history.dict() for history in paginations.items]
data = {
'histories': histories,
'has_prev': paginations.has_prev,
'has_next': paginations.has_next,
'page': paginations.page
}
return ResponseUtil.standard_response(1, data)
def save(user_id):
id = RequestUtil.get_parameter(request, 'id', None)
title = RequestUtil.get_parameter(request, 'title', None)
completed = RequestUtil.get_parameter(request, 'completed', None)
if completed == 'true':
completed = True
else:
completed = False
if id:
todo = Todo.query.filter_by(id=id).first()
else:
todo = Todo(user_id=user_id,
add_time=DateUtil.now_datetime()) # new todo
if todo and todo.user_id == user_id:
# update it.
if title:
todo.title = title
if completed is not None:
todo.completed = completed
# print todo.dict()
todo.save()
return ResponseUtil.standard_response(1, todo.dict())
else:
return ResponseUtil.standard_response(0, 'save error.')
def api_server_new(ip, port, account, pkey, name=None, id=None):
# login user
user_id = RequestUtil.get_login_user().get('id', '')
server_id = id
name = name if name else ip
try:
success, log = SshUtil.do_ssh_cmd(
ip, port, account, pkey, 'ls -lh', timeout=5)
if success:
if server_id:
# update webhook
# you can only update the webhook which you create.
server = Server.query.filter_by(
id=server_id, user_id=user_id).first()
if not server:
return ResponseUtil.standard_response(
0, 'Server is not exist!')
server.ip = ip
server.port = port
server.account = account
server.pkey = pkey
server.name = name
else:
server = Server(ip=ip, port=port, account=account, pkey=pkey,
user_id=user_id, name=name)
server.save()
return ResponseUtil.standard_response(
1, server.dict(with_pkey=True))
except Exception as e:
print(e)
return ResponseUtil.standard_response(0, 'Server SSH connect error!')
def api_collaborator_new(webhook_id, user_id):
# login user
login_user_id = RequestUtil.get_login_user().get('id', '')
if login_user_id == user_id:
return ResponseUtil.standard_response(0, '`%s` is Creator!' % user_id)
if not AuthUtil.has_admin_auth(login_user_id, webhook_id):
return ResponseUtil.standard_response(0, 'Permission deny!')
collaborator = Collaborator.query.filter_by(webhook_id=webhook_id,
user_id=user_id).first()
# not exist
if collaborator:
return ResponseUtil.standard_response(0, 'Collaborator exist!')
# 开始添加
user = User.query.get(user_id)
if not user:
user = User(id=user_id, name=user_id)
user.save()
collaborator = Collaborator(webhook_id=webhook_id, user=user)
collaborator.save()
return ResponseUtil.standard_response(1, collaborator.dict())
def loginApi(username, password):
user = User.query.filter_by(username=username).first()
if not user or not user.verify_password(password):
return ResponseUtil.standard_response(0, '用户名不存在或密码错误')
user.last_login = DateUtil.now_datetime()
user.save()
RequestUtil.login_user(user.dict())
return ResponseUtil.standard_response(1, user.dict())
def del_redis():
md5 = RequestUtil.get_parameter('md5', '')
redis_info = RedisInfo.query.get(md5)
if redis_info:
redis_info.delete()
return ResponseUtil.standard_response(1, 'Success!')
return ResponseUtil.standard_response(0, 'Not Found!')
def remove(user_id):
id = RequestUtil.get_parameter(request, 'id', None)
if id:
todo = Todo.query.filter_by(id=id).first()
if todo:
todo.delete()
return ResponseUtil.standard_response(1, 'remove success.')
return ResponseUtil.standard_response(0, 'remove error.')
def register(username, password, email):
# username = request.json.get('úsername')
# password = request.json.get('password')
# email = request.json.get('email')
if User.query.filter_by(username=username).first() is not None:
return ResponseUtil.standard_response(0, 'user is exist')
user = User(username=username, email=email)
user.hash_password(password)
user.save()
return ResponseUtil.standard_response(1, user.dict())
def upload_file():
file = request.files['image']
if file and allowed_file(file.filename):
filename = secure_filename(file.filename)
unix_time = DateUtil.now_timestamp()
ext = filename.rsplit('.', 1)[1]
new_filename = str(unix_time) + '.' + ext
file.save(os.path.join(app.config['UPLOAD_FOLDER'], new_filename))
return ResponseUtil.standard_response(0, IMAGE_URL + new_filename)
return ResponseUtil.standard_response(0, '请上传图片！')
def api_server_delete(server_id):
# login user
user_id = RequestUtil.get_login_user().get('id', '')
server = Server.query.filter_by(user_id=user_id, id=server_id).first()
if not server:
return ResponseUtil.standard_response(0, 'Permission deny!')
server.deleted = True
server.save()
return ResponseUtil.standard_response(1, 'Success')
def api_collaborator_list(webhook_id):
# login user
user_id = RequestUtil.get_login_user().get('id', '')
if not AuthUtil.has_readonly_auth(user_id, webhook_id):
return ResponseUtil.standard_response(0, 'Permission deny!')
collaborators = Collaborator.query.filter_by(webhook_id=webhook_id).all()
collaborators = [collaborator.dict() for collaborator in collaborators]
return ResponseUtil.standard_response(1, collaborators)
def api_webhook_delete():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
webhook_id = RequestUtil.get_parameter('webhook_id', '')
webhook = WebHook.query.filter_by(user_id=user_id, id=webhook_id).first()
if not webhook:
return ResponseUtil.standard_response(0, 'Permition deny!')
webhook.delete()
return ResponseUtil.standard_response(1, 'Success')
def api_server_new():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
ip = RequestUtil.get_parameter('ip', '')
name = RequestUtil.get_parameter('name', ip)
name = name and name or ip
port = RequestUtil.get_parameter('port', 22)
account = RequestUtil.get_parameter('account', '')
pkey = RequestUtil.get_parameter('pkey', '')
if not all((ip, name, port, account, pkey)):
return ResponseUtil.standard_response(0, 'Form data can not be blank!')
try:
success, log = SshUtil.do_ssh_cmd(ip,
port,
account,
pkey,
'ls -lh',
timeout=5)
if success:
server_id = RequestUtil.get_parameter('id', '')
if server_id:
# update webhook
# you can only update the webhook which you create.
server = Server.query.filter_by(id=server_id,
user_id=user_id).first()
if not server:
return ResponseUtil.standard_response(
0, 'Server is not exist!')
server.ip = ip
server.port = port
server.account = account
server.pkey = pkey
server.name = name
else:
server = Server(ip=ip,
port=port,
account=account,
pkey=pkey,
user_id=user_id,
name=name)
server.save()
return ResponseUtil.standard_response(1,
server.dict(with_pkey=True))
except Exception as e:
print(e)
return ResponseUtil.standard_response(0, 'Server SSH connect error!')
def api_webhook_delete():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
webhook_id = RequestUtil.get_parameter('webhook_id', '')
# 验证创建者权限
webhook = AuthUtil.has_admin_auth(user_id, webhook_id)
if not webhook:
return ResponseUtil.standard_response(0, 'Permission deny!')
webhook.deleted = True
webhook.save()
return ResponseUtil.standard_response(1, 'Success')
def flushall_redis():
try:
md5 = RequestUtil.get_parameter('md5', '')
db = RequestUtil.get_parameter('db', '0')
redis_info = RedisInfo.query.get(md5)
if redis_info:
r = RedisUtil.flushall(redis_info.host, redis_info.port,
redis_info.password, db)
if r:
return ResponseUtil.standard_response(1, 'Success!')
return ResponseUtil.standard_response(0, 'Flush db error!')
return ResponseUtil.standard_response(0, 'Not Found!')
except:
return ResponseUtil.standard_response(0, 'Connect to redis error!')
def api_webhook_list():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
# create webhooks
created_webhooks = WebHook.query.filter_by(user_id=user_id,
deleted=False).all()
# collaborator webhooks
collaborated_webhooks = \
WebHook.query.join(Collaborator,
Collaborator.webhook_id == WebHook.id) \
.filter(Collaborator.user_id == user_id) \
.filter(WebHook.deleted == false()).all()
webhooks = created_webhooks + collaborated_webhooks
# to dict
webhooks = {'id%s' % webhook.id: webhook for webhook in webhooks}
# value
webhooks = webhooks.values()
# sort
sorted(webhooks, key=lambda webhook: webhook.id)
webhooks = [webhook.dict(True) for webhook in webhooks]
return ResponseUtil.standard_response(1, webhooks)
def api_collaborator_delete(collaborator_id):
# login user
user_id = RequestUtil.get_login_user().get('id', '')
collaborator = Collaborator.query.get(collaborator_id)
if not collaborator:
return ResponseUtil.standard_response(0, 'Permission deny!')
webhook_id = collaborator.webhook_id
if not AuthUtil.has_admin_auth(user_id, webhook_id):
return ResponseUtil.standard_response(0, 'Permission deny!')
collaborator.delete()
return ResponseUtil.standard_response(1, 'Success')
def api_webhook_list():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
webhooks = AuthUtil.has_auth_webhooks(user_id)
# 转json
webhooks = [webhook.dict(True) for webhook in webhooks]
return ResponseUtil.standard_response(1, webhooks)
def api_webhook_list():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
webhooks = WebHook.query.filter_by(user_id=user_id, deleted=False).all()
webhooks = [webhook.dict(True) for webhook in webhooks]
return ResponseUtil.standard_response(1, webhooks)
def api_server_list():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
servers = Server.query.filter_by(user_id=user_id, deleted=False).all()
servers = [server.dict(with_pkey=True) for server in servers]
return ResponseUtil.standard_response(1, servers)
def api_webhook_new():
# login user
user_id = RequestUtil.get_login_user().get('id', '')
server_id = RequestUtil.get_parameter('server_id', '')
# server must be added by yourself
if not Server.query.filter_by(id=server_id, user_id=user_id).first():
return ResponseUtil.standard_response(0, 'Permition deny!')
repo = RequestUtil.get_parameter('repo', '')
branch = RequestUtil.get_parameter('branch', '')
shell = RequestUtil.get_parameter('shell', '')
if not all((repo, branch, shell, server_id)):
return ResponseUtil.standard_response(0, 'Form data can not be blank!')
webhook_id = RequestUtil.get_parameter('id', '')
if webhook_id:
# update webhook
# you can only update the webhook which you create.
webhook = WebHook.query.filter_by(
id=webhook_id, user_id=user_id).first()
if not webhook:
return ResponseUtil.standard_response(0, 'WebHook is not exist!')
webhook.repo = repo
webhook.branch = branch
webhook.shell = shell
webhook.server_id = server_id
else:
# new webhook
webhook = WebHook(
repo=repo,
branch=branch,
shell=shell,
server_id=server_id,
user_id=user_id,
key=StringUtil.md5_token()
)
webhook.save()
return ResponseUtil.standard_response(1, webhook.dict(with_key=True))
def add_redis():
host = request.form.get("host")
port = request.form.get("port")
password = request.form.get("password")
md5 = StringUtil.md5(host + str(port))
redis_info = RedisInfo.query.get(md5)
if redis_info:
redis_info.password = password
else:
redis_info = RedisInfo(md5=md5,
host=host,
port=port,
password=password)
redis_info.save()
return ResponseUtil.standard_response(redis_info.dict())
def api(api):
user_id = RequestUtil.get_login_user(session)
rst = hanlder.get(api, for_404)(user_id)
if rst:
return rst
return ResponseUtil.standard_response(1, 'test')
def for_404(user_id):
ResponseUtil.standard_response(0, '404')
def drop(user_id):
Todo.query.filter_by(user_id=user_id).delete()
return ResponseUtil.standard_response(1, 'drop success.')
def findAll(user_id):
todos = Todo.query.filter_by(user_id=user_id)
todos = [todo.dict() for todo in todos]
return ResponseUtil.standard_response(1, todos)