class UserValidator:
"""
Series of tools to validate and process user info by application API
"""
# Description of expected fields for Swagger documentation
fields = api.model(
'User', {
'email':
restplus_fields.String(description='User email', required=True),
'password':
restplus_fields.String(description='User password', required=True),
})
class RequestValidator(Schema):
""" Validates request data for described fields
"""
email = marshmallow_fields.Email(required=True)
password = marshmallow_fields.String(required=True)
class ModelSerializer(Schema):
""" Serializes model data.
Example of usage:
users = User.get_all()
users = UserSchema(many=True).dump(users)
return jsonify(users)
"""
class Meta:
""" Describes exposed model fields
"""
fields = ("id", "email", "created", "updated", "last_login",
"last_logout", "last_request")
class CretaUser(Resource):
# @ns_user.response(201, '创建用户成功')
# @ns_user.expect(user)
user = api.model(
'Model User', {
'username': fields.String(required=True, description='用户名'),
'nickname': fields.String(required=False, description='昵称'),
'password': fields.String(required=True, description='密码'),
'phone': fields.String(required=False, description='手机号码'),
'email': fields.String(required=False, description=''),
'is_children': fields.Integer(required=False, description=''),
'parent_id': fields.String(required=False, description='')
})
@ns_user.expect(user)
@auth.login_required
def post(self):
"""
创建用户
"""
data = request.json
if data.get('password') == '' or data.get('password') is None:
# abort() 立即停止视图函数的执行，并且把相对应的信息返回到前端中
# abort(Response("密码不能为空"))
return jsonify(code=Ret.FAILURE, msg="密码不能为空")
creata_user(data)
# return None, 201
return jsonify(code=Ret.SUCCESS, msg="创建成功")
class login(Resource):
# 请求参数
login = api.model(
'Login', {
'username': fields.String(required=True, description='用户名'),
'password': fields.String(required=True, description='密码')
})
@ns_user.expect(login)
def post(self):
"""
登录，获取用户信息以及生成token
:return:
"""
data = request.json
username = data.get('username')
password = data.get('password')
user = User.query.filter(User.username == username).first()
if User.verify_password(user, password):
# 生成token
token = user.generate_auth_token()
return jsonify(code=Ret.SUCCESS,
msg="登录成功",
data={
'token': token.decode('utf-8'),
'name': user.username
})
else:
return jsonify(code=Ret.FAILURE, msg="密码错误")
class UserDto:
post_model = api.model(
"UserPostModel", {
"id": fields.Integer(required=False),
"username": fields.String(description="用户名，必传", required=True),
"password": fields.String(description="密码，必传", required=True)
})
delete_model = reqparse.RequestParser()
delete_model.add_argument("user_id", type=int, required=True, help="用户id")
need_minimal = api.model(
'Need Minimal', {
'id':
fields.String(required=True, description='Need unique ID'),
'created_at':
fields.DateTime(dt_format='iso8601',
required=False,
description='Need creation datetime'),
'customer':
fields.String(required=True,
description='Customer unique name',
min_length=3,
max_length=64),
'customer_obj':
fields.Nested(
customer_minimal, required=True, description='Customer Object'),
'contact':
fields.String(required=True,
description='Customer contact name',
min_length=3,
max_length=64),
'contact_obj':
fields.Nested(
contact_minimal, required=True, description='Customer Object'),
'title':
fields.String(required=True,
description='Need title',
min_length=3,
max_length=64),
'start_at_latest':
fields.String(required=False,
dt_format='iso8601',
description='Need start at latest date'),
'status':
fields.String(required=True,
description='Need status (open, win, lost)')
})
from flask import jsonify, request
from app.api import api, ns
from flask_restplus import Resource, fields
from app.models.users import User, UserSchema, db
user_fields = api.model('User', {
'name': fields.String,
'email': fields.String
})
user_schema = UserSchema(many=True)
@ns.route('/user')
class UserListAPI(Resource):
def get(self):
page_param = request.args.get('page')
if not page_param:
page_param = 1
paginate = User.query.paginate(page=int(page_param), per_page=2)
queryset = User.query.all()
queryset = user_schema.dump(paginate.items).data
endpoint = request.url_rule
return jsonify({
'data': queryset,
'message': 'data have been successfully fetched',
'error': False,
'meta': {
date_created = db.Column(db.DateTime, default=db.func.current_timestamp())
date_modified = db.Column(db.DateTime, default=db.func.current_timestamp(),
onupdate=db.func.current_timestamp())
# Model Class for sqlAlchemy
class Developer(Base):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(20))
focus = db.Column(db.String(50))
def __init__(self, name, focus):
self.name = name
self.focus = focus
# Model Class for marshmallows
class DeveloperSchema(ma.SQLAlchemyAutoSchema):
class Meta:
model = Developer
class DeveloperReturnSchema(ma.SQLAlchemyAutoSchema):
class Meta:
model = Developer
# Exclude date_created because we're aliasing it below
exclude = ("name", "focus")
# Model for restplus
DeveloperRestSchema=api.model('Developer',{
'name': fields.String(),
'focus': fields.String(),
})
from app.database.models import User
from app.database.db import db
from app.api.errors import error_response
from app.api import subscribe_ns, api, unsubscribe_ns
from app.api.access_control import auth_required
parser = reqparse.RequestParser()
parser.add_argument('Authorization',
location='headers',
help='Bearer token',
required=True)
subscribe_response = api.model(
'Subscribe', {
'message':
fields.String(description='Subscription status',
example="Subscribed successfully")
})
unsubscribe_response = api.model(
'Unsubscribe', {
'message':
fields.String(description='Subscription status',
example="Unsubscribed successfully")
})
@subscribe_ns.route('')
class SubscribeApi(Resource):
@api.response(201, 'Success', model=subscribe_response)
@api.response(400, 'Invalid authentication header')
# coding=utf-8
import logging
from flask_restplus import fields
from app.api import api
__author__ = 'LongHB'
_logger = logging.getLogger(__name__)
_keyword_recommenders_data = api.model(
'keyword_recommenders_data', {
'query': fields.String(attribute='keyword'),
})
keyword_recommenders_response = api.model(
'keyword_recommenders_response',
{'keywords': fields.Nested(_keyword_recommenders_data)})
_category_choosable_data = api.model('category_choosable_data', {
'code': fields.String(),
'id': fields.Integer(),
'name': fields.String(),
})
category_choosable_response = api.model(
'category_choosable_response',
{'categories': fields.Nested(_category_choosable_data)})
_brand_choosable_data = api.model(
'brand_choosable_data', {
'code': fields.String(),
# coding=utf-8
import logging
from flask_restplus import fields
from app.api import api
__author__ = 'LongHB'
_logger = logging.getLogger(__name__)
_order_price = api.model(
'order_price', {
'sku': fields.String(),
'price': fields.Float(),
'promotion_price': fields.Float()
})
order_checking_response = api.model(
'order_checking_response', {
'prices':
fields.Nested(_order_price),
'total_price':
fields.Float(),
'failed_sku':
fields.List(fields.String(), description='List of sku out of stocks'),
})
order_creating_response = api.model(
'order_response', {
'status':
fields.String(description='status of this action (ok or failed)'),
'failed_sku':
def getConnection():
return pymysql.connect(host='localhost',
user='******',
password='******',
db='jumble',
charset='utf8mb4',
cursorclass=pymysql.cursors.DictCursor)
user_model = api.model(
'User', {
'id': fields.Integer,
'name': fields.String,
'email': fields.String,
'major': fields.String,
'slack': fields.String,
'first_hack': fields.Boolean,
'image': fields.String
})
user_id_model = api.model('User', {'id': fields.Integer})
user_model_post = api.model(
'User', {
'name': fields.String,
'email': fields.String,
'major': fields.String,
'slack': fields.String,
'first_hack': fields.Boolean,
'image': fields.String
from app.api import api
from flask_restx import fields
id_model = api.model('ID', {'id': fields.Integer(description='ID.')})
login_model = api.model(
'Login', {
'email':
fields.String(description='Email address for account.', required=True),
'password':
fields.String(description='Password for account.', required=True)
})
tokens_model = api.model(
'Token', {
'access_token': fields.String(description='Access Token.',
required=True),
'refresh_token': fields.String(description='Refresh Token.',
required=True)
})
create_user_modal = api.model(
'New User', {
'email':
fields.String(description='Email address of new user.', required=True),
'group':
fields.Integer(
description=
'Optional ID of the group for the user to be added to, can be omitted.'
)
})
def Mod(*args, **kwargs):
name = args[0]
if not isinstance(name, str):
name = __gen_mod_name()
return api.model(name, *args, **kwargs)
return api.model(*args, **kwargs)
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app.api import api
customer_minimal = api.model(
'Customer Minimal', {
'id':
fields.String(required=True, description='Customer unique ID'),
'name':
fields.String(required=True,
description='Customer name',
min_length=3,
max_length=64),
})
contact_minimal = api.model(
'Contact Minimal', {
'id':
fields.String(required=True, description='Contact unique ID'),
'name':
fields.String(required=True,
description='Contact name',
min_length=3,
max_length=64)
})
customer_data_container = api.model(
'Customer DataContainer',
{'customers': fields.List(fields.Nested(customer_minimal))})
from app.message import Message
from app.queue import L2_DATASOURCES
from app.api import api
ns = api.namespace(
'message',
description='Operations to add messages to be displayed on the clock')
message = api.model(
'Message', {
'text':
fields.String(description='The text of the messae'),
'icon':
fields.String(description='Optional URL to an icon to include'),
'repeat':
fields.Integer(description='Number times to display the message'),
'interval_sec':
fields.Integer(
description='Minimum number of seconds between message repeats'),
'display_sec':
fields.Integer(
description='Minimum number of seconds the messaage is visible')
})
@ns.route('/')
@api.expect(message)
@api.response(404, 'Message was not added.')
class MessageEP(Resource):
"""
Enqueue a message in the botton line of the clock display.
from flask import jsonify, request, Blueprint
from app.api import api, ns
from flask_restplus import Resource, fields
from app.tables.models import Born, BornSchema, db
from app.api.custom_response import custom_response
born_fields = api.model('Born', {
})
born_schema = BornSchema(many=True)
@ns.route('/born', methods=['GET', 'POST'])
class ListBorn(Resource):
def get(self):
queryset = Born.query.all()
queryset = born_schema.dump(queryset).data
return jsonify({
'data' : queryset,
'message' : 'Query OK',
'error' : False
})
@api.doc(body=born_fields)
def post(self):
data = request.get_json(force=True)
if data:
try:
queryset = Born()
queryset.nama_bayi = data['nama_bayi']
queryset.tempat_lahir = data['tempat_lahir']
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app.api import api
auth_token = api.model('Auth Token', {
'token': fields.String(required=True, description='Auth token')
})
from flask_restx import fields
from app.api import api
message = api.model("Message", {
"message": fields.String(max_length=255)
})
token = api.model("Token", {
"token": fields.String(max_length=40),
"exp": fields.DateTime()
})
user_register = api.model("Registration", {
"username": fields.String(min_length=6, max_length=20),
"password": fields.String(min_length=8, max_length=20),
"email": fields.String(max_length=120)
})
user_update = api.inherit("Update user", user_register, {
"image": fields.String(max_length=80, desctiption="Profile picture path on the server")
})
user_info = api.inherit("Full user info", user_update, {
"last_login": fields.DateTime()
})
help='Bearer token',
required=True)
del_parser.add_argument('filter',
type=str,
required=False,
help='Supported operators >,<,=,!=,AND,OR',
location='args')
meta_data = api.model(
'meta', {
'total_items':
fields.Integer(required=True, description='Total users', example=5),
'page':
fields.Integer(required=True,
description='Current page number',
example=2,
default=1),
'total_pages':
fields.Integer(required=True, description='Total pages', example=4),
'per_page':
fields.Integer(
required=True, description='Users per page', example=10, min=1)
})
user_info = api.model(
'user', {
'id':
fields.Integer(required=True, description='User id', example=5),
'username':
fields.String(required=True, description='Username',
example='athlete'),
# -*- coding: utf-8 -*-
from flask_restplus import fields
from marshmallow import fields as f, Schema
from app.api import api
class MetaSchema(Schema):
id = f.Int()
descricao = f.Str()
tipo = f.Int()
schema = MetaSchema()
model = api.model('meta', {
'id': fields.Integer,
'descricao': fields.String,
'tipo': fields.Integer
})
from app.api import api
from flask_restplus import fields
UserModel = api.model(
'User', {
'Username': fields.String(),
'Email Address': fields.String(),
'Password': fields.String()
})
TodoModel = api.model('Todo', {'Body': fields.String()})
from flask_restplus import fields
from app.api import api
blog_post = api.model(
'Blog post', {
'id':
fields.String(readOnly=True,
description='The unique identifier of a blog post'),
'slug':
fields.String(readOnly=True, description='slug of the article title'),
'title':
fields.String(required=True, description='Article title'),
'body':
fields.String(required=True, description='Article content'),
'pub_date':
fields.DateTime,
'created_date':
fields.DateTime(readOnly=True),
'categories':
fields.List(fields.String),
})
pagination = api.model(
'A page of results', {
'page':
fields.Integer(description='Number of this page of results'),
'pages':
fields.Integer(description='Total number of pages of results'),
'per_page':
fields.Integer(description='Number of items per page of results'),
'total':
# @Author : Guohao
# @Time : 2019-07-19 14:46
# 接口输入输出
from flask_restplus import fields
from app.api import api
user = api.model('Model User', {
'id': fields.String(readOnly=False, description='用户id'),
'username': fields.String(required=False, description='用户名'),
'nickname': fields.String(required=False, description='昵称'),
'password': fields.String(required=False, description='密码'),
'phone': fields.String(required=False, description='手机号码'),
'email': fields.String(required=False, description=''),
'is_children': fields.Integer(required=False, description=''),
'parent_id': fields.String(required=False, description=''),
'status': fields.String(required=False, description=''),
'founder': fields.String(required=False, description=''),
'founder_name': fields.String(required=False, description=''),
'foundtime': fields.DateTime(required=False, description=''),
'updater': fields.String(required=False, description=''),
'updater_name': fields.String(required=False, description=''),
'updatetime': fields.DateTime(required=False, description='')
})
pagination = api.model('A page of results', {
'page': fields.Integer(description='Number of this page of results'),
'pages': fields.Integer(description='Total number of pages of results'),
'per_page': fields.Integer(description='Number of items per page of results'),
'total': fields.Integer(description='Total number of results'),
})
from flask import jsonify, request, Blueprint
from app.api import api, ns
from flask_restplus import Resource, fields
from app.tables.models import GroupHasRole, GroupHasRoleSchema, db
grouphasrole_fields = api.model('GroupHasrole', {
'id_group': fields.Integer,
'id_role': fields.Integer
})
@ns.route('/grouphasrole')
class ListGrouphasRole(Resource):
def get(self):
"""Returns list of Group Has Role."""
from flask import jsonify, make_response, request
from flask_restplus import Resource, fields
from flask_jwt_extended import create_access_token
from app.database.models import User
from app.api.errors import error_response
from app.api import auth_ns, api
auth_fields = api.model('Auth', {
'password': fields.String(required=True, description='Password', example='secure_password'),
'username': fields.String(required=True, description='Username', example='athlete')
})
auth_response = api.model('Acess Token', {
'access_token': fields.String(description='Bearer acess Token', example="secure_access_token")
})
@auth_ns.route('')
class AuthApi(Resource):
@api.expect(auth_fields)
@api.response(201, 'Success', model=auth_response)
@api.response(400, 'Bad request')
@api.response(401, 'Incorrect username or password')
def post(self):
""" Authorise user and provide access token"""
username = request.json.get('username')
password = request.json.get('password')
user = User.find_by_username(username)
if not user:
return error_response('Username does not exist', 401)
from flask_restx import fields
from app.api import api
TicketSerializer = api.model('Ticket', {
'id': fields.Integer(required=False, description='ticket identification number.'),
'number': fields.String(required=False, description='ticket number.'),
'timestamp': fields.DateTime(required=False, description='date and time of ticket generation.'),
'date': fields.DateTime(required=False, description='date of ticket generation.'),
'name': fields.String(required=False, description='registered ticket stored value.'),
'n': fields.Boolean(required=False, description='ticket is registered.'),
'p': fields.Boolean(required=False, description='ticket is processed.'),
'pdt': fields.DateTime(required=False, description='ticket pulled date and time.'),
'pulledBy': fields.Integer(required=False, description='user id or token id that pulled ticket.'),
'on_hold': fields.Boolean(required=False, description='ticket is put on hold.'),
'status': fields.String(required=False, description='ticket processing status.'),
'office_id': fields.Integer(required=False, description='office ticket belongs to.'),
'task_id': fields.Integer(required=False, description='task ticket belongs to.'),
})
TaskSerializer = api.model('Task', {
'id': fields.Integer(required=False, description='task identification number.'),
'name': fields.String(required=False, description='task name.'),
'timestamp': fields.DateTime(required=False, description='date and time of task creation.'),
'hidden': fields.Boolean(required=False, description='task is is hidden in the touch screen.'),
})
# -*- coding: utf-8 -*-
from flask_restplus import fields
from app.api import api
consultant_minimal = api.model(
'Consultant Minimal', {
'id':
fields.String(required=True, description='Consultant unique ID'),
'name':
fields.String(required=True,
description='Consultant name',
min_length=3,
max_length=64),
})
consultant_data_container = api.model(
'Consultant DataContainer',
{'consultants': fields.List(fields.Nested(consultant_minimal))})
from flask import request
from flask_restplus import Resource, abort, fields, reqparse
from app import db
from app.api import api
from app.models import Customer
customer_model = api.model(
'Customer',
{
'id': fields.String(readonly=True),
'name': fields.String(required=True, example='John'),
}
)
pagination = api.model(
'Page Model', {
'page': fields.Integer(
description='Number of this page of results'
),
'per_page': fields.Integer(
description='Number of items per page of results'
),
'total_pages': fields.Integer(
description='Total number of pages of results'
),
'total_items': fields.Integer(description='Total number of results'),
'next_page': fields.String(),
'prev_page': fields.String()
}
)
required=True)
del_parser = reqparse.RequestParser()
del_parser.add_argument('Authorization',
location='headers',
help='Bearer token',
required=True)
del_parser.add_argument('filter',
type=str,
required=False,
help='Supported operators >,<,=,!=,AND,OR',
location='args')
del_info = api.model(
'Del', {
'count':
fields.Integer(
required=True, description='Number of users deleted', example=3)
})
meta_data = api.model(
'meta', {
'total_items':
fields.Integer(required=True, description='Total users', example=5),
'page':
fields.Integer(required=True,
description='Current page number',
example=2,
default=1),
'total_pages':
fields.Integer(required=True, description='Total pages', example=4),
'per_page':
