def put(self, url_id):
""" 编辑 url """
url = URL.query.get_or_404(url_id)
params = request.json
path = params.get('path', '').strip().replace(' ', '')
protocol_id = params.get('protocol_id', 0)
system_id = params.get('system_id', 0)
supporter_id = params.get('supporter_id', 0)
if not (params and protocol_id and system_id and supporter_id) and is_contain_zh(path):
return response(code=1, message='参数错误，且接口中不能包含中文')
protocol = Protocol.query.get_or_404(protocol_id)
system = System.query.get_or_404(system_id)
supporter = User.query.get_or_404(supporter_id)
# 判断 path 是否存在
existed_url = system.urls.filter(URL.path == path).first()
if existed_url and existed_url.id != url.id:
return response(code=1, message=f'{path} 已存在，请勿重复添加')
url.path = path
url.desc = params.get('desc'),
url.protocol_id = protocol.id,
url.system_id = system.id,
url.supporter_id = supporter.id
db.session.add(url)
db.session.commit()
return response()
def delete(self, protocol_id):
""" 删除协议 """
# TODO 增加权限控制
protocol = Protocol.query.get_or_404(protocol_id)
if protocol.methods.count() > 0:
return response(code=1, message=f'协议 {protocol.name} 中已包含方法，无法删除')
db.session.delete(protocol)
db.session.commit()
return response()
def delete(self, project_id):
""" 删除项目 """
# TODO 增加权限控制
project = Project.query.get_or_404(project_id)
if project.systems.count() > 0:
return response(code=1, message='项目中存在系统，无法删除')
db.session.delete(project)
db.session.commit()
return response(message='删除成功')
def get(self, user_id):
""" 获取用户信息 """
if user_id == g.current_user.id:
user = g.current_user
else:
user = User.query.get(user_id)
if not user:
return response(code=1, message='用户不存在')
return response(data={'user': user.to_json()})
def delete(self, m_id):
""" 删除方法 """
method = Method.query.get_or_404(m_id)
# TODO 增加权限控制
if method.api_docs:
return response(code=1, message='此方法已经被使用，请联系管理员')
db.session.delete(method)
db.session.commit()
return response()
def put(self, protocol_id, name):
""" 编辑协议 """
protocol = Protocol.query.get_or_404(protocol_id)
cap_name = name.upper()
existed_protocol = Protocol.query.filter_by(name=cap_name).first()
if existed_protocol and existed_protocol.id != protocol.id:
return response(code=1, message='协议名已存在，请勿重复添加')
protocol.name = cap_name
db.session.add(protocol)
db.session.commit()
return response()
def post(self, name):
""" 新建协议 """
# TODO 将中文校验放入 webargs Schema 统一校验
cap_name = name.upper()
existed_protocol = Protocol.query.filter_by(name=cap_name).first()
if existed_protocol:
return response(code=1, message='协议名已存在，请勿重复添加')
protocol = Protocol(name=cap_name)
db.session.add(protocol)
db.session.commit()
return response()
def post(self, protocol_id, name):
""" 新建方法 """
protocol = Protocol.query.get_or_404(protocol_id)
cap_name = name.upper()
existed_method = protocol.methods.filter(
Method.name == cap_name).first()
if existed_method:
return response(code=1, message=f'请求方式 {cap_name} 已存在请勿重复添加')
method = Method(name=cap_name, protocol_id=protocol_id)
db.session.add(method)
db.session.commit()
return response()
def post(self, email, username, password):
user = User.query.filter_by(email=email).first()
if user is not None:
return response(code=1, message=f'邮箱 {user.email} 已存在')
user = User.query.filter_by(username=username).first()
if user is not None:
return response(code=1, message=f'用户名 {user.username} 已存在')
user = User(username=username, email=email)
user.set_password(password)
db.session.add(user)
db.session.commit()
return response(message='注册成功')
def put(self, m_id, name, protocol_id):
""" 编辑方法 """
method = Method.query.get_or_404(m_id)
protocol = Protocol.query.get_or_404(protocol_id)
cap_name = name.upper()
existed_method = protocol.methods.filter(
Method.name == cap_name).first()
if existed_method and existed_method.id != method.id:
return response(code=1, message=f'请求方式 {cap_name} 已存在请勿重复添加')
method.name = cap_name
method.protocol_id = protocol_id
db.session.add(method)
db.session.commit()
return response()
def post(self, name, desc, domains, supporter_id):
""" 新增项目 """
exited_project = Project.query.filter_by(name=name).first()
if exited_project:
return response(code=1, message='项目已存在，请勿重复添加')
supporter = User.query.get_or_404(supporter_id)
project = Project(name=name,
desc=desc,
domains=domains,
supporter_id=supporter.id)
db.session.add(project)
db.session.commit()
return response(data={'project': project.to_json()})
def put(self, project_id, name, desc, domains, supporter_id):
""" 编辑项目 """
project = Project.query.get_or_404(project_id)
existed_project = Project.query.filter_by(name=name).first()
if existed_project and existed_project.id != project.id:
return response(code=1, message='项目已存在，请勿重复添加')
supporter = User.query.get_or_404(supporter_id)
project.name = name
project.desc = desc
project.domains = domains
project.supporter_id = supporter.id
db.session.add(project)
db.session.commit()
return response(data={'project': project.to_json()})
def exception(e):
error_code = hasattr(e, 'code') and e.code or 1
if hasattr(e, 'description'):
message = e.description
else:
message = e.args[0]
return response(code=error_code, message=message)
def handle_validation_error(e):
exc = e.exc
message = ''
for k, v in exc.messages.items():
message += f'参数 {k} {" ".join(v)} '
return response(code=e.code, message=message)
def get(self, page, per_page):
paginate = User.query.paginate(page, per_page, error_out=False)
data = {
'projects': [p.to_json() for p in paginate.items],
'count': paginate.total,
'paginate': paginate.page
}
return response(data=data)
def post(self, project_id, name, desc, domains, supporter_id):
""" 新建系统 """
project = Project.query.get_or_404(project_id)
supporter = User.query.get_or_404(supporter_id)
existed_system = project.systems.filter(System.name == name).first()
if existed_system:
return response(code=1, message=f'系统 {name} 已存在，请勿重复添加')
system = System(name=name,
desc=desc,
domains=domains,
project_id=project.id,
supporter_id=supporter.id)
db.session.add(system)
db.session.commit()
return response(data={'system': system.to_json()})
def get(self, user_id, page, per_page):
""" 获取用户所创建的 uri """
user = User.query.get_or_404(user_id)
paginate = user.urls.paginate(page, per_page, error_out=False)
data = {
'urls': [u.to_json() for u in paginate.items],
'count': paginate.total,
'paginate': paginate.page
}
return response(data=data)
def get(self, project_id, page, per_page):
""" 获取项目下的项目集 """
project = Project.query.get_or_404(project_id)
paginate = project.systems.order_by(System.id.desc()).paginate(
page, per_page, error_out=False)
data = {
'systems': [s.to_json() for s in paginate.items],
'count': paginate.total,
'paginate': paginate.page
}
return response(data=data)
def get(self, user_id, page, per_page):
""" 获取用户收藏的项目 """
user = User.query.get_or_404(user_id)
paginate = ProjectCollect.query.with_parent(user).order_by(
ProjectCollect.timestamp.desc()).paginate(page,
per_page,
error_out=False)
data = {
'projects': [c.project.to_json() for c in paginate.items],
'count': paginate.total,
'paginate': paginate.page
}
return response(data=data)
def post(self, grant_type, username, password):
if grant_type.lower() != 'password':
return api_abort(code=400, message='The grant type must be password.')
user = User.query.filter_by(username=username).first()
if user is None or not user.validate_password(password):
return api_abort(code=400, message='Either the username or password was invalid.')
token, expiration = generate_token(user)
headers = {
'Cache-Control': 'no-store',
'Pragma': 'no-cache'
}
data = {
'access_token': token,
'token_type': 'Bearer',
'expires_in': expiration
}
return response(data=data, headers=headers)
def post(self):
return response()
def patch(self, url_id):
return response()
def get(self, m_id):
""" 获取方法信息 """
method = Method.query.get_or_404(m_id)
return response(data={'method': method.to_json()})
def delete(self, url_id):
""" 删除 URL """
URL.query.filter_by(id=url_id).delete(synchronize_session=False)
return response()
def get(self, url_id):
""" 获取 URL 详情 """
url = URL.query.get_or_404(url_id)
return response(data={'url': url.to_json()})
def get(self, sys_id):
""" 获取项目下的项目集 """
system = System.query.get_or_404(sys_id)
urls = system.urls.all()
return response(data={'urls': [u.to_json() for u in urls]})
def patch(self, m_id):
return response()
def patch(self, protocol_id):
return response()
def get(self, protocol_id):
""" 获取协议 """
protocol = Protocol.query.get_or_404(protocol_id)
return response(data={'protocol': protocol.to_json()})
def get(self, protocol_id):
protocol = Protocol.query.get_or_404(protocol_id)
return response(
data={'methods': [m.to_json() for m in protocol.methods]})
