def test_parse_required(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", required=True, location='values')
message = ''
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, (u'Missing required parameter foo in the '
'post body or the query string'))
parser = RequestParser()
parser.add_argument("bar", required=True, location=['values', 'cookies'])
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, (u"Missing required parameter bar in the "
"post body or the query string or the "
"request's cookies"))
def bad_choice():
parser = RequestParser()
parser.add_argument("foo", choices=["one", "two"])
req = Mock(["values"])
req.values = MultiDict([("foo", "three")])
parser.parse_args(req)
abort.assert_called_with(400, message="three is not a valid choice")
def bad_choice():
parser = RequestParser()
parser.add_argument('foo', choices=['one', 'two'])
req = Mock(['values'])
req.values = MultiDict([('foo', 'three')])
parser.parse_args(req)
abort.assert_called_with(400, message='three is not a valid choice')
def test_parse_required(self):
app = Flask(__name__)
with app.app_context():
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", required=True, location='values')
message = ''
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, ({'foo': 'Missing required parameter in '
'the post body or the query '
'string'}))
parser = RequestParser()
parser.add_argument("bar", required=True, location=['values', 'cookies'])
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
self.assertEquals(message, ({'bar': 'Missing required parameter in '
'the post body or the query '
'string or the request\'s '
'cookies'}))
def test_help(self, abort):
from werkzeug.datastructures import MultiDict
parser = RequestParser()
parser.add_argument('foo', choices=['one', 'two'], help='Bad choice')
req = Mock(['values'])
req.values = MultiDict([('foo', 'three')])
parser.parse_args(req)
abort.assert_called_with(400, message='Bad choice')
def test_parse_choices(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument("foo", choices=["bat"]),
with self.assertRaises(exceptions.BadRequest):
parser.parse_args(req)
def test_parse_choices_sensitive(self):
req = Request.from_values("/bubble?foo=BAT")
parser = RequestParser()
parser.add_argument("foo", choices=["bat"], case_sensitive=True),
with self.assertRaises(exceptions.BadRequest):
parser.parse_args(req)
def test_help(self, abort):
parser = RequestParser()
parser.add_argument('foo', choices=['one', 'two'], help='Bad choice')
req = Mock(['values'])
req.values = MultiDict([('foo', 'three')])
parser.parse_args(req)
expected = '[foo]: (Bad choice) three is not a valid choice'
abort.assert_called_with(400, message=expected)
def test_parse_required(self):
req = Request.from_values("/bubble")
parser = RequestParser()
parser.add_argument("foo", required=True)
with self.assertRaises(exceptions.BadRequest):
parser.parse_args(req)
def test_not_json_location_and_content_type_json(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument("foo", location="args")
with app.test_request_context("/bubble", method="get", content_type="application/json"):
parser.parse_args() # Should not raise a 400: BadRequest
def test_not_json_location_and_content_type_json(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument('foo', location='args')
with app.test_request_context('/bubble', method='get',
content_type='application/json'):
parser.parse_args() # Should not raise a 400: BadRequest
def test_parse_lte_gte_mock(self):
mock_type = Mock()
req = Request.from_values("/bubble?foo<=bar")
parser = RequestParser()
parser.add_argument("foo", type=mock_type, operators=["<="])
parser.parse_args(req)
mock_type.assert_called_with("bar", "foo", "<=")
def test_help(self, abort):
from werkzeug.datastructures import MultiDict
parser = RequestParser()
parser.add_argument("foo", choices=["one", "two"], help="Bad choice")
req = Mock(["values"])
req.values = MultiDict([("foo", "three")])
parser.parse_args(req)
abort.assert_called_with(400, message="Bad choice")
def test_no_help(self, abort):
with self.assertRaises(exceptions.BadRequest):
from werkzeug.datastructures import MultiDict
parser = RequestParser()
parser.add_argument('foo', choices=['one', 'two'])
req = Mock(['values'])
req.values = MultiDict([('foo', 'three')])
parser.parse_args(req)
abort.assert_called_with(400, message='three is not a valid choice')
def test_help_with_unicode_error_msg(self, abort):
app = Flask(__name__)
with app.app_context():
parser = RequestParser()
parser.add_argument('foo', choices=('one', 'two'), help=u'Bad choice: {error_msg}')
req = Mock(['values'])
req.values = MultiDict([('foo', u'\xf0\x9f\x8d\x95')])
parser.parse_args(req)
expected = {'foo': u'Bad choice: \xf0\x9f\x8d\x95 is not a valid choice'}
abort.assert_called_with(400, message=expected)
def test_help_no_error_msg(self, abort):
app = Flask(__name__)
with app.app_context():
parser = RequestParser()
parser.add_argument('foo', choices=['one', 'two'], help='Please select a valid choice')
req = Mock(['values'])
req.values = MultiDict([('foo', 'three')])
parser.parse_args(req)
expected = {'foo': 'Please select a valid choice'}
abort.assert_called_with(400, message=expected)
def test_help_with_unicode_error_msg(self, abort):
app = Flask(__name__)
with app.app_context():
parser = RequestParser()
parser.add_argument("foo", choices=("one", "two"), help=u"Bad choice: {error_msg}")
req = Mock(["values"])
req.values = MultiDict([("foo", u"\xf0\x9f\x8d\x95")])
parser.parse_args(req)
expected = {"foo": u"Bad choice: \xf0\x9f\x8d\x95 is not a valid choice"}
abort.assert_called_with(400, message=expected)
def test_help_no_error_msg(self, abort):
app = Flask(__name__)
with app.app_context():
parser = RequestParser()
parser.add_argument("foo", choices=["one", "two"], help="Please select a valid choice")
req = Mock(["values"])
req.values = MultiDict([("foo", "three")])
parser.parse_args(req)
expected = {"foo": "Please select a valid choice"}
abort.assert_called_with(400, message=expected)
def test_int_range_choice_types(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument("foo", type=int, choices=range(100), location="json")
with app.test_request_context(
"/bubble", method="post", data=json.dumps({"foo": 101}), content_type="application/json"
):
try:
parser.parse_args()
self.fail()
except exceptions.BadRequest:
pass
def test_int_choice_types(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument("foo", type=int, choices=[1, 2, 3], location='json')
with app.test_request_context(
'/bubble', method='post',
data=json.dumps({'foo': 5}),
content_type='application/json'
):
try:
parser.parse_args()
self.fail()
except exceptions.BadRequest:
pass
def test_viewargs(self):
req = Mock()
req.view_args = {"foo": "bar"}
parser = RequestParser()
parser.add_argument("foo", location=["view_args"], type=str)
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bar")
req = Mock()
req.values = ()
req.view_args = {"foo": "bar"}
parser = RequestParser()
parser.add_argument("foo", type=str)
args = parser.parse_args(req)
self.assertEquals(args["foo"], None)
def post(self):
"""Adds in a new youtube video for processing."""
parser = RequestParser()
parser.add_argument('url', required=True)
args = parser.parse_args()
logging.info('Enqueing {url:s}', args)
# parse youtube url in the form of http://youtube.com/watch?v=<VIDEO_ID>
# parse the extracted query to get the first available 'v' param
parsed = parse.urlparse(args['url'])
video_id = parse.parse_qs(parsed.query).get('v')[0]
logging.debug('Found video_id {0}', video_id)
if not video_id:
msg = "Could not extract video_id (found '{0}') from {1}".format(
video_id, args['url'])
logging.warn(msg)
return abort(400, message=msg)
res = chain(
tasks.captions.youtube_captions_from_video.s(video_id),
tasks.captions.annotate_events_in_captions.s(video_id),
tasks.captions.event_dates_from_timeml_annotated_captions.s(),
tasks.wikitext.wikipedia_events_from_dates.s(),
tasks.wikitext.event_entities_from_wikitext.s(),
tasks.wikitext.match_event_via_entities.s(),
tasks.wikitext.resolve_match_link_topics.s(),
# tasks.requests.send_url_payload(app.config['WIKITEXT_PAYLOAD_DEST_URL']),
).apply_async()
return {
'url': args['url'],
'video_id': video_id,
'task_id': res.id
}
def test_parse_foo_operators_four_hunderd(self):
app = Flask(__name__)
with app.app_context():
parser = RequestParser()
parser.add_argument("foo", type=int),
self.assertRaises(exceptions.BadRequest, lambda: parser.parse_args(Request.from_values("/bubble?foo=bar")))
def post(self, name):
user_auth = request.headers['Authorization']
parser = RequestParser()
parser.add_argument('message', type=str, required=True)
message = parser.parse_args()['message']
server = get_instance()
server.handle_message(user_auth, name, message)
def post(self):
parser = RequestParser()
parser.add_argument('name', type=str, required=True)
args = parser.parse_args()
server = get_instance()
args['user_auth'] = request.headers['Authorization']
server.join_room(**args)
def test_passing_arguments_object(self):
req = Request.from_values("/bubble?foo=bar")
parser = RequestParser()
parser.add_argument(Argument("foo", type=str))
args = parser.parse_args(req)
self.assertEquals(args['foo'], u"bar")
def test_parse_lte(self):
req = Request.from_values("/bubble?foo<=bar")
parser = RequestParser()
parser.add_argument("foo", operators=["<="])
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bar")
def test_viewargs(self):
req = Request.from_values()
req.view_args = {"foo": "bar"}
parser = RequestParser()
parser.add_argument("foo", location=["view_args"])
args = parser.parse_args(req)
self.assertEquals(args['foo'], "bar")
req = Mock()
req.values = ()
req.json = None
req.view_args = {"foo": "bar"}
parser = RequestParser()
parser.add_argument("foo", store_missing=True)
args = parser.parse_args(req)
self.assertEquals(args["foo"], None)
def test_trim_request_parser(self):
req = Request.from_values("/bubble?foo= 1 &bar=bees&n=22")
parser = RequestParser(trim=False)
parser.add_argument('foo')
args = parser.parse_args(req)
self.assertEquals(args['foo'], ' 1 ')
parser = RequestParser(trim=True)
parser.add_argument('foo')
args = parser.parse_args(req)
self.assertEquals(args['foo'], '1')
parser = RequestParser(trim=True)
parser.add_argument('foo', type=int)
args = parser.parse_args(req)
self.assertEquals(args['foo'], 1)
def test_parse_unicode(self):
req = Request.from_values("/bubble?foo=barß")
parser = RequestParser()
parser.add_argument("foo")
args = parser.parse_args(req)
self.assertEquals(args['foo'], u"barß")
def test_parse_error_bundling_w_parser_arg(self):
app = Flask(__name__)
app.config['BUNDLE_ERRORS']=False
with app.app_context():
req = Request.from_values("/bubble")
parser = RequestParser(bundle_errors=True)
parser.add_argument("foo", required=True, location='values')
parser.add_argument("bar", required=True, location=['values', 'cookies'])
message = ''
try:
parser.parse_args(req)
except exceptions.BadRequest as e:
message = e.data['message']
error_message = {'foo': 'Missing required parameter in the post '
'body or the query string',
'bar': 'Missing required parameter in the post '
'body or the query string or the request\'s '
'cookies'}
self.assertEquals(message, error_message)
def test_get_json_location(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument("foo", location="json")
with app.test_request_context('/bubble',
method="post",
data=json.dumps({"foo": "bar"}),
content_type='application/json'):
args = parser.parse_args()
self.assertEquals(args['foo'], 'bar')
def post(self):
# 1.获取参数 -- post请求体以json格式传递参数
# 1.1 mobile 手机号码
# 1.2 code 用户填写的短信验证码
# 2.参数校验--RequestParser参数提取和参数校验
# 构建解析对象
parser = RequestParser()
parser.add_argument("mobile",
required=True,
location="json",
type=regex(r'^1[3-9]\d{9}$'))
parser.add_argument("code",
required=True,
location="json",
type=regex(r'\d{6}'))
param_ret = parser.parse_args()
mobile = param_ret['mobile']
sms_code = param_ret['sms_code']
# 3业务逻辑处理
key = "app:code:{}".format(mobile)
real_smscode = redis_client.get(key)
redis_client.delete(key)
if real_smscode is None:
return {"message": "短信验证码为空"}
if sms_code != real_smscode:
return {"message": "短信验证码错误"}
# 3.3 短信验证码通过
# 3.4 根据手机号码作为查询条件，查询用户对象是否存在
# select * from xxxx where xx
# 优化查询：options(load_only(User.id))
user = User.query.options(load_only(
User.id)).filter(User.mobile == mobile).first()
if user is None:
user = User(mobile=mobile, name=mobile, last_login=datetime.now())
db.session.add(user)
else:
user.last_login = datetime.now()
try:
db.session.commit()
except Exception as e:
db.session.rollback()
return {"message": f"数据库提交异常{e}"}, 507
# 3.8 生成2小时有效的登录token和14天有效的刷新token
login_token, refresh_token = self.get_token(user_id=user.id)
# 4返回值处理
return {"login_token": login_token, "refresh_token": refresh_token}
class UserCreate(Resource):
def __init__(self):
self.reqparse = RequestParser()
self.reqparse.add_argument(
'user',
type=validate_username,
required=True,
location='json'
)
self.reqparse.add_argument(
'key',
type=validate_pubkey,
required=True,
location='json'
)
self.reqparse.add_argument(
'host',
type=str,
required=True,
location='json'
)
super(UserCreate, self).__init__()
def post(self):
args = self.reqparse.parse_args()
try:
post_data = {
"name": str(args["user"]),
"host": args["host"],
"shell": "/bin/bash",
"keys": [args["key"]],
}
r = requests.post(
"http://userdb-api.userdb-api.svc/signup",
json=post_data
)
print("{status_code} - {user} - {text}".format(
status_code=r.status_code,
user=args['user'],
text=r.text
))
if r.status_code >= 400:
data = r.json()
return {'message': data['message']}, r.status_code
except Exception as e:
(typ, value, tb) = sys.exc_info()
sys.stderr.write("Unexpected Error: %r\n" % e)
traceback.print_tb(tb)
return {'message': 'User creation script failed'}, 500
return {'message': 'success'}
class RoleResource(Resource):
"""
角色管理
"""
def __init__(self):
self.parser = RequestParser()
@permission_required
def get(self):
'''
获取全部角色列表
'''
# 获取参数
self.parser.add_argument("offset",
type=int,
location="args",
default=0,
help='页码')
self.parser.add_argument("size",
type=int,
location="args",
default=10,
help='每页数量')
self.parser.add_argument("order_by",
type=str,
location="args",
default='-create_time',
help='排序')
self.args = self.parser.parse_args()
try:
roles, total = self.get_roles()
except Exception as e:
return pretty_result(http_code.DB_ERROR)
if roles:
roles = RoleSchema().dump(roles.all(), many=True)
for role in roles:
role['permissions'] = Tree(role['permissions'], 'id',
'parent').generate()
return pretty_result(http_code.OK,
data={
'items': roles,
'total': total
})
def get_roles(self):
query_obj = Role.query
total = query_obj.count()
order_by = self.args.order_by if self.args.order_by else '-create_time'
order = text(f'-role.{order_by[1:]}') \
if order_by.startswith('-') else text(f'role.{order_by}')
return query_obj.order_by(order).offset(self.args.offset).limit(
self.args.size), total
def get(self):
"""
获取用户列表
"""
args_parser = RequestParser()
args_parser.add_argument('page',
type=inputs.positive,
required=False,
location='args')
args_parser.add_argument('per_page',
type=inputs.int_range(constants.PER_PAGE_MIN,
constants.PER_PAGE_MAX,
'per_page'),
required=False,
location='args')
args_parser.add_argument('keyword', location='args')
args_parser.add_argument('begin',
type=parser.date_time,
location='args')
args_parser.add_argument('end', type=parser.date_time, location='args')
args_parser.add_argument('status',
type=inputs.int_range(0, 1),
location='args')
args_parser.add_argument('order_by', location='args')
args = args_parser.parse_args()
page = constants.DEFAULT_PAGE if args.page is None else args.page
per_page = constants.DEFAULT_PER_PAGE if args.per_page is None else args.per_page
users = User.query
if args.keyword:
users = users.filter(
or_(User.mobile.like('%' + args.keyword + '%'),
User.account.like('%' + args.keyword + '%')))
if args.status is not None:
users = users.filter(User.status == args.status)
if args.begin and args.end and args.end > args.begin:
users = users.filter(User.last_login.between(args.begin, args.end))
if args.order_by is not None:
if args.order_by == 'id':
users = users.order_by(User.id.asc())
else:
users = users.order_by(User.last_login.desc())
else:
users = users.order_by(User.last_login.asc())
total_count = users.count()
users = users.offset(per_page * (page - 1)).limit(per_page).all()
ret = marshal(users, UserListResource.user_fields, envelope='users')
ret['total_count'] = total_count
return ret
def patch(self):
"""
编辑用户的信息
"""
db.session().set_to_write()
json_parser = RequestParser()
json_parser.add_argument('name',
type=inputs.regex(r'^.{1,7}$'),
required=False,
location='json')
json_parser.add_argument('intro',
type=inputs.regex(r'^.{0,60}$'),
required=False,
location='json')
json_parser.add_argument('email',
type=parser.email,
required=False,
location='json')
args = json_parser.parse_args()
user_id = g.user_id
new_cache_values = {}
new_user_values = {}
return_values = {'id': user_id}
if args.name:
new_cache_values['name'] = args.name
new_user_values['name'] = args.name
return_values['name'] = args.name
if args.intro:
new_cache_values['intro'] = args.intro
new_user_values['introduction'] = args.intro
return_values['intro'] = args.intro
if args.email:
# TODO email 缓存
new_user_values['email'] = args.email
return_values['email'] = args.email
try:
if new_user_values:
User.query.filter_by(id=user_id).update(new_user_values)
except IntegrityError:
db.session.rollback()
return {'message': 'User name has existed.'}, 409
db.session.commit()
if new_cache_values:
cache_user.UserProfileCache(user_id).clear()
return return_values, 201
class PackageDetailResource(Resource):
"""
package detail资源类
"""
def __init__(self):
self.parser = RequestParser()
def get(self):
"""
套餐细节信息
:return: json
"""
self.parser.add_argument("no", type=str, required=True, location="args",
help='no is required')
args = self.parser.parse_args()
package_list = PackageModel.query.filter_by(no=args.no).all()
items = []
for package in package_list:
fileList = []
fileList2 = []
url = config.domain + "/api/v1/pictureManagement/get?type=package&id=" + package.picture
fileList.append({"name": package.picture, "url": url})
description = package.description.split(",")
for i in description:
url2 = config.domain + "/api/v1/pictureManagement/get?type=package&id=" + i
fileList2.append({"name": i, "url": url2})
items.append(
{
'id': package.id,
'no': package.no,
'name': package.name,
'type': package.type,
'gender': package.gender,
'size': package.size,
'age': package.age,
'Pclass': package.Pclass,
'count': package.count,
# 'price': package.price,
# 'total': package.total,
'point': package.point,
'picture': fileList,
'description': fileList2,
'remark': package.remark,
'updateUser': package.updateUser,
'updateTime': package.update_time.strftime("%m/%d/%Y %H:%M:%S")
}
)
if items:
return pretty_result(code.OK, data=items, msg='Get package detail successful！')
else:
return pretty_result(code.ERROR, data=[], msg='The package id is exit！')
def get(self):
parser = RequestParser()
parser.add_argument('page', type=int, default=DEFAULT_PAGE)
parser.add_argument('pageSize', type=int, default=DEFAULT_PAGE_SIZE)
parser.add_argument('name', type=str)
parser.add_argument('starttime', type=int)
parser.add_argument('endtime', type=int)
parser.add_argument('include', type=str)
parser.add_argument('exclude', type=str)
parser.add_argument('username', type=str)
args = parser.parse_args(strict=True)
criterion = set()
criterion.add(OperationalRecord.ylc == args['name'])
if args['starttime']:
criterion.add(OperationalRecord.creatTime >= args['starttime'])
if args['endtime']:
criterion.add(OperationalRecord.creatTime <= args['endtime'])
if args["include"]:
a = args["include"].split(',')
b = []
for i in a:
c = '%{}%'.format(i)
b.append(c)
criterion.add(or_(*[OperationalRecord.remark.like(w) for w in b]))
if args["exclude"]:
a = args["exclude"].split(',')
b = []
for i in a:
c = '%{}%'.format(i)
b.append(c)
criterion.add(
and_(*[OperationalRecord.remark.notlike(w) for w in b]))
if args['username']:
criterion.add(OperationalRecord.username == args['username'])
query = db.session.query(OperationalRecord).order_by(
OperationalRecord.creatTime.desc())
result = []
pagination = paginate(query, criterion, args['page'], args['pageSize'])
for item in pagination.items:
result.append({
'id': item.id,
'username': item.username,
'createtime': item.creatTime,
'remark': item.remark
})
return make_response(result,
page=pagination.page,
pages=pagination.pages,
total=pagination.total)
def post(self):
parser = RequestParser()
parser.add_argument("name", type=str, location='json', required=True)
parser.add_argument("password", type=str, location='json', required=True)
user_info = parser.parse_args(strict=True)
u = User(name=user_info['name'])
u.password = user_info['password']
id = u.create()
if id:
return {'id': id}
else:
raise Exception("create user failed!")
def get(self):
parser = RequestParser()
parser.add_argument('name')
parser.add_argument('age')
# 执行解析, 默认会从查询字符串/post-form/post-json数据 进行参数提取
args = parser.parse_args()
print(args.name)
print(args.age)
return {'foo': 'get'}
def delete(self):
parser = RequestParser(trim=True)
parser.add_argument('id', type=str)
args = parser.parse_args(strict=True)
try:
for id in args['id'].split(','):
temp = MessageInbox.query.get(int(id))
db.session.delete(temp)
db.session.commit()
except:
db.session.rollback()
db.session.remove()
return {"success": True}
def put(self, name):
parser = RequestParser()
parser.add_argument("age")
args = parser.parse_args()
if name in users:
user = users[name]
user["age"] = args["age"]
return user, 200
user = {"name": name, "age": args.age}
users[name] = user
return user, 201
def validate_request():
if not request.json:
abort(400)
request_parser = RequestParser(bundle_errors=True)
request_parser.add_argument("name",
required=True,
help="name field is required.")
request_parser.add_argument("born",
required=True,
help="born field is required.")
arguments = request_parser.parse_args()
if arguments:
return arguments
def get(self):
parser = RequestParser(trim=True)
parser.add_argument('agents', type=str)
parser.add_argument('startTime', type=str)
parser.add_argument('endTime', type=str)
parser.add_argument('page', type=int, default=1)
parser.add_argument('pageSize', type=int, default=30)
args = parser.parse_args(strict=True)
res = MemberFanshuiPc().getFanshuiDetail(**args)
return make_response(data=res[0],
page=res[1],
pages=res[2],
total=res[3])
def post(self):
parser = RequestParser(trim=True)
parser.add_argument('name', type=str, required=True, nullable=False)
args = parser.parse_args()
if not args['name']:
return {'success': False, "error_msg": "标签名错误"}
res = CodeLabel.insert_label(args['name'])
if res:
return {'success': True, "msg": "标签名创建成功"}
else:
return {'success': False, "msg": "标签名创建失败"}
def test_both_json_and_values_location(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument('foo', type=int)
parser.add_argument('baz', type=int)
with app.test_request_context('/bubble?foo=1', method="post",
data=json.dumps({"baz": 2}),
content_type='application/json'):
args = parser.parse_args()
self.assertEquals(args['foo'], 1)
self.assertEquals(args['baz'], 2)
def post(self):
json_parser = RequestParser()
json_parser.add_argument('id',
type=str,
required=True,
location='json')
args = json_parser.parse_args()
user = Administrator.query.filter_by(id=args.id).first()
new_password = self._generate_code()
user.password = new_password
db.session.add(user)
db.session.commit()
return {"password": new_password}
def test_parse_append_many_location_json(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument("foo", action='append', location="json")
with app.test_request_context('/bubble',
method="post",
data=json.dumps({"foo": ["bar",
"bar2"]}),
content_type='application/json'):
args = parser.parse_args()
self.assertEquals(args['foo'], ['bar', 'bar2'])
def get(self):
res_parser = RequestParser()
res_parser.add_argument('user_id', required=True, action='append', type=int)
res_parser.add_argument('sex', required=True, help='missing a param')
res_parser.add_argument('age', required=True, type=inputs.int_range(1, 100))
res_parser.add_argument('phone', required=True, type=mobile_checkout)
res = res_parser.parse_args()
user_id = res.user_id
sex = res.sex
age = res.age
phone = res.phone
return {'data': {'user_id': user_id, 'sex': sex, 'age': age, 'phone': phone}}
def test_list_argument(self):
app = Flask(__name__)
parser = RequestParser()
parser.add_argument('arg1', location='json', type=list)
with app.test_request_context('/bubble',
method="post",
data=json.dumps({'arg1': ['foo',
'bar']}),
content_type='application/json'):
args = parser.parse_args()
self.assertEquals(args['arg1'], ['foo', 'bar'])
class Order(ApiResource):
def __init__(self):
self.parser = RequestParser()
self.parser.add_argument('order_id', type=str)
self.parser.add_argument('operation', type=str)
# @orders.route('/get_order', methods=['POST'])
# @login_required
def get(self):
data = self.parser.parse_args()
order_id = data['order_id']
order = order_controller.get_order(order_id)
return jsonify(order)
# @orders.route('/<string:order_id>/close', methods=['POST'])
# @login_required
# @orders.route('/<string:order_id>/checkout', methods=['POST'])
# @login_required
def post(self):
data = self.parser.parse_args()
operation = data['operation']
order_id = data['order_id']
if operation == 'close':
try:
order = order_controller.close_order(order_id)
except Exception as e:
traceback.print_exc()
return str(e), 409
return jsonify(order)
elif operation == 'checkout':
try:
order = order_controller.checkout_order(order_id)
except Exception as e:
traceback.print_exc()
return str(e), 409
return jsonify(order)
else:
return '', 404
def get(self):
parser = RequestParser(trim=True)
parser.add_argument('page', type=int, default=DEFAULT_PAGE)
parser.add_argument('pageSize', type=int, default=DEFAULT_PAGE_SIZE)
parser.add_argument('agentUsername', type=str)
parser.add_argument('timeLower', type=int)
parser.add_argument('timeUpper', type=int)
args = parser.parse_args(strict=True)
pagination = paginate(CommissionLog.query,
page=args['page'],
per_page=args['pageSize'])
return make_response_from_pagination(pagination)
def post(self):
parser = RequestParser()
parser.add_argument('mobile',
required=True,
location='json',
type=mobile_type)
parser.add_argument('code',
required=True,
location='json',
type=regex(r'^\d{6}$'))
args = parser.parse_args()
mobile = args.mobile
code = args.code
# 验证验证码是否存在和正确:
key = 'app:code:{}'.format(mobile)
test_code = redis_client.get(key)
print(mobile)
print(code)
print(key)
print(test_code)
if not test_code or test_code != code:
return {'message': 'Invalid Code', 'data': None}, 400
# redis_client.delete(key)
# 验证成功，从数据库查找用户
conn = self.User.user
result = conn.find_one({'mobile': mobile})
if result is None or result == []:
user_data = {
'name': mobile,
'mobile': mobile,
'last_login': datetime.now(),
'age': random.randint(15, 35)
}
conn.insert_one(user_data)
result = conn.find_one({'mobile': mobile})
else:
conn.update({'mobile': mobile},
{'$set': {
'last_login': datetime.now()
}},
upsert=True)
print(result)
# 生成token
token = generate_jwt(
{'userid': str(result['_id'])},
expiry=datetime.utcnow() +
timedelta(days=current_app.config['JWT_EXPIRE_DAYS']))
return {'token': token}, 201
def post():
json_parser = RequestParser()
json_parser.add_argument('id',
type=int,
required=True,
location='json')
json_parser.add_argument('meta',
type=str,
required=True,
location='json')
json_parser.add_argument('fullPath',
type=str,
required=True,
location='json')
json_parser.add_argument('name',
type=str,
required=True,
location='json')
json_parser.add_argument('order',
type=str,
required=True,
location='json')
json_parser.add_argument('path',
type=str,
required=True,
location='json')
json_parser.add_argument('redirect',
type=str,
required=False,
location='json')
json_parser.add_argument('remark',
type=str,
required=False,
location='json')
json_parser.add_argument('status',
type=int,
required=True,
location='json')
args = json_parser.parse_args()
menu = AdministratorMenu.query.filter_by(id=args.id).first()
menu.meta = json.dumps(dict(eval(args.meta)), ensure_ascii=False)
menu.full_path = args.fullPath
menu.name = args.name
menu.menu_order = args.order
menu.path = args.path
menu.redirect = args.redirect
menu.redirect = args.remark
menu.status = args.status
db.session.add(menu)
db.session.commit()
return "ok"
def post(self):
"""
发表文章
"""
req_parser = RequestParser()
req_parser.add_argument('draft', type=inputs.boolean, required=False, location='args')
req_parser.add_argument('title', type=inputs.regex(r'.{5,30}'), required=True, location='json')
req_parser.add_argument('content', type=inputs.regex(r'.+'), required=True, location='json')
req_parser.add_argument('cover', type=self._cover, required=True, location='json')
req_parser.add_argument('channel_id', type=self._channel_id, required=True, location='json')
args = req_parser.parse_args()
content = args['content']
cover = args['cover']
draft = args['draft']
# 对于自动封面，生成封面
cover_type = cover['type']
if cover_type == -1:
cover = self._generate_article_cover(content)
article_id = current_app.id_worker.get_id()
article = Article(
id=article_id,
user_id=g.user_id,
channel_id=args['channel_id'],
title=args['title'],
cover=cover,
status=Article.STATUS.DRAFT if draft else Article.STATUS.UNREVIEWED
)
db.session.add(article)
article_content = ArticleContent(id=article_id, content=content)
db.session.add(article_content)
# TODO 已废弃
article_statistic = ArticleStatistic(id=article_id)
db.session.add(article_statistic)
try:
db.session.commit()
except Exception as e:
current_app.logger.error(e)
db.session.rollback()
return {'message': 'Server has something wrong.'}, 507
# if not draft:
# TODO 机器审核
# TODO 新文章消息推送
return {'id': article_id}, 201
def post(self):
"""
关注用户
"""
# 解析参数
json_parser = RequestParser()
json_parser.add_argument('target', required=True, location='json')
args = json_parser.parse_args()
target = args.target
if target == g.user_id:
return {'message': 'User cannot follow self.'}, 400
ret = 1
# 往数据库中存储关注情况
try:
follow = Relation(user_id=g.user_id, target_user_id=target, relation=Relation.RELATION.FOLLOW)
db.session.add(follow)
db.session.commit()
except IntegrityError:
db.session.rollback()
ret = Relation.query.filter(Relation.user_id == g.user_id,
Relation.target_user_id == target,
Relation.relation != Relation.RELATION.FOLLOW)\
.update({'relation': Relation.RELATION.FOLLOW})
db.session.commit()
if ret > 0:
timestamp = time.time()
# 用户的关注列表中缓存层中追加数据
user.UserFollowingCache(g.user_id).update(target, timestamp)
# 作者的粉丝列表中缓存层中追加数据
user.UserFollowersCache(target).update(g.user_id, timestamp)
# 统计数据的持久化存储
statistic.UserFollowingCountStorage.incr(g.user_id)
statistic.UserFansCountStorage.incr(target)
"""发送关注通知"""
# 获取粉丝的基本信息
_user = user.UserProfileCache(g.user_id).get()
_data = {
'user_id': g.user_id,
'user_name': _user['name'],
'user_photo': _user['profile_photo'],
'timestamp': int(time.time())
}
# 将推送通知发送给IM服务器(放入消息队列中) 将消息发送到作者的用户id对应的房间 target="2"
current_app.siomgr.emit('following notify', _data, room=target)
return {'target': target}, 201
def get(self):
"""
获取联想建议
"""
qs_parser = RequestParser()
qs_parser.add_argument('q', type=inputs.regex(r'^.{1,50}$'), required=True, location='args')
args = qs_parser.parse_args()
q = args.q
# 先尝试自动补全建议查询
query = {
'from': 0,
'size': 10,
'_source': False,
'suggest': {
'word-completion': {
'prefix': q,
'completion': {
'field': 'suggest'
}
}
}
}
ret = current_app.es.search(index='completions', body=query)
options = ret['suggest']['word-completion'][0]['options']
# 如果没得到查询结果，进行纠错建议查询
if not options:
query = {
'from': 0,
'size': 10,
'_source': False,
'suggest': {
'text': q,
'word-phrase': {
'phrase': {
'field': '_all',
'size': 1
}
}
}
}
ret = current_app.es.search(index='articles', doc_type='article', body=query)
options = ret['suggest']['word-phrase'][0]['options']
results = []
for option in options:
if option['text'] not in results:
results.append(option['text'])
return {'options': results}
def post(self):
"""
@@@
## 同意用户的申诉请求
**管理员同意用户的申请请求**
### header args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| token | false | string | 管理员的token |
### args
| 参数名 | 是否可选 | type | remark |
|--------|--------|--------|--------|
| report_id | false | string | 要处理的申诉id |
### return
无data
@@@
"""
parser = RequestParser()
parser.add_argument('token',
type=str,
required=True,
location='headers')
parser.add_argument('report_id', type=str, required=True)
req = parser.parse_args()
token = req.get('token')
report_id = req.get('report_id')
admin_name = verify_admin_token(token)
if admin_name == None:
return {'success': False, 'message': '请以管理员身份操作'}, 403
report_ref = db.collection('report').document(report_id)
report = report_ref.get()
report_dict = report.to_dict()
if report_dict['status'] == 1:
return {'success': True, 'message': '该申诉信息已经处理'}, 200
else:
report_ref.update({u'status': 1})
author_id = report_dict['author_id']
author_ref = db.collection('author').document(author_id)
author = author_ref.get()
if not author.exists:
return {'success': False, 'message': '作者不存在'}, 403
if not 'bind_user' in author.to_dict():
return {'success': False, 'message': '作者未被认领'}, 200
#获得该作者绑定的用户名
username = author.to_dict()['bind_user']
cancel_bind_author(author_id, username)
return {'success': True, 'message': '处理申诉信息成功'}, 200
def put(self, target):
"""
修改id=target管理员信息
"""
json_parser = RequestParser()
json_parser.add_argument('account', type=parser.mis_account, location='json')
json_parser.add_argument('password', type=parser.mis_password, location='json')
json_parser.add_argument('name', location='json')
json_parser.add_argument('group_id', type=parser.mis_group_id, location='json')
json_parser.add_argument('status', type=inputs.int_range(0, 1), location='json')
json_parser.add_argument('email', type=parser.email, location='json')
json_parser.add_argument('mobile', type=parser.mobile, location='json')
json_parser.add_argument('current_password', type=parser.mis_password, location='json')
args = json_parser.parse_args()
print(args)
administrator = MisAdministrator.query.filter_by(id=target).first()
if not administrator:
return {'message': 'Invalid administrator id.'}, 403
if args.account and args.account != administrator.account:
if MisAdministrator.query.filter_by(account=args.account).first():
return {'message': '{} already exists'.format(args.account)}
administrator.account = args.account
if args.password:
if target == g.administrator_id \
and administrator.password != generate_password_hash(args.current_password):
return {'message': 'Current password error.'}, 403
administrator.password = generate_password_hash(args.password)
if args.name:
administrator.name = args.name
if args.group_id:
administrator.group_id = args.group_id
if args.status is not None:
administrator.status = args.status
if args.email:
administrator.email = args.email
if args.mobile:
administrator.mobile = args.mobile
try:
db.session.add(administrator)
db.session.commit()
except:
db.session.rollback()
raise
return marshal(administrator, AdministratorListResource.administrators_fields), 201
