def post(self):
schema = UserSchema()
user = schema.load(request.json)
db.session.add(user)
db.session.commit()
return {"msg": "user created", "user": schema.dump(user)}, 201
def get(self, uid):
schema = UserSchema()
if not request.is_json:
return jsonify({'msg': 'Missing JSON in request'}), 400
user = Users.objects.get_or_404(id=uid)
return schema.jsonify(user)
def put(self, user_id):
schema = UserSchema(partial=True)
user = User.query.get_or_404(user_id)
user = schema.load(request.json, instance=user)
db.session.commit()
return {"msg": "user updated", "user": schema.dump(user)}
def get(self, user_id):
schema = UserSchema()
user = User.query.get(user_id)
if user:
ret = {"data": schema.dump(user.__dict__)}
return status_code.SUCCESS.set_data(schema.dump(user.__dict__)), 200
else:
return status_code.NOT_FOUND.d, 200
def export_list():
query = User.query
schema = UserSchema(many=True)
datas = query.all()
is_or_not_map = common_fun.get_dict_map(const.IS_OR_NOT_DICT_KEY)
for r in datas:
r.is_caiyin = is_or_not_map.get(str(r.is_caiyin), r.is_caiyin)
return status_code.SUCCESS.set_data(schema.dump(datas)).d, 200
def put(self, user_id):
session = db.session
schema = UserSchema(partial=True)
user = User.query.get(user_id)
user = schema.load(request.json, instance=user)
session.merge(user)
# session.flush()
return status_code.SUCCESS.d, 200
def get(self):
user = get_current_user()
session = db.session
session.refresh(user)
# user.roles = [user.roles]
schema = UserSchema(unknown=True)
if user:
return status_code.SUCCESS.set_data(schema.dump(user.__dict__)).d, 200
else:
return status_code.USER_NOT_FOUND.d, 200
def post(self):
schema = UserSchema()
user, errors = schema.load(request.json)
if errors:
return errors, 422
user.save()
return schema.jsonify(user)
def put(self, uid):
schema = UserSchema(partial=True)
if not request.is_json:
return jsonify({'msg': 'Missing JSON in request'}), 400
user = Users.objects.get_or_404(id=uid)
user, errors = schema.load(request.json)
if errors:
return errors, 422
user.save()
return schema.jsonify(user)
def test_dump_user(dummy_user):
data = UserSchema().dump(dummy_user)
assert data == {
'id': str(dummy_user.id),
'email_address': dummy_user.email_address,
'verified': False
}
def test_invalid_password_length():
data = {
'email_address': '{{cookiecutter.test_email_address}}',
'password': '******'
}
with pytest.raises(ValidationError) as validation_error:
UserSchema().load(data)
assert validation_error.value.messages == {
'password': ["Shorter than minimum length 8."]
}
def signup():
'''Authenticate user and return token
'''
if not request.is_json:
return make_response(
jsonify(msg='Missing JSON in request'), 400)
schema = UserSchema()
user, errors = schema.load(request.json)
if errors:
return jsonify(errors), 422
try:
user.passwd_digest = pwd_context.hash(user.passwd_digest)
user.save()
except NotUniqueError as e:
return make_response(
jsonify(msg='User exists with under that email/username'),
422
)
return schema.jsonify(user)
def test_load_user_email_already_exists(dummy_user):
data = {
'email_address': '{{cookiecutter.test_email_address}}',
'password': '******'
}
save(dummy_user)
with pytest.raises(ValidationError) as validation_error:
UserSchema().load(data)
assert validation_error.value.messages == {
'email_address': ['A user with this email address already exists.']
}
def get(self):
schema = UserSchema(many=True)
users = Users.objects()
return paginate(users, schema)
def get(self, user_id):
schema = UserSchema()
user = User.query.filter_by(id=user_id).first_or_404()
return schema.dump(user)
def post(self):
schema = UserSchema(unknown=True)
user = schema.load(request.json)
db.session.add(user)
# db.session.flush()
return status_code.SUCCESS.d, 200
def get(self):
return UserSchema().dump(self.context)
from flask import request
from flask_restful import Resource
from http import HTTPStatus
from marshmallow import ValidationError
from {{cookiecutter.app_name}}.libs.authentication import Auth
from {{cookiecutter.app_name}}.models import UserModel
from {{cookiecutter.app_name}}.schemas import UserSchema
user_schema = UserSchema()
REQUEST_NOT_VALID = 'Request not valid.'
USER_NOT_FOUND = 'User not found.'
USER_EXISTS = 'User exists.'
USER_INVALID_CREDENTIAL = 'Invalid credential.'
class Login(Resource):
@classmethod
def post(self):
user_json = request.get_json()
data, error = user_schema.load(user_json, partial=True)
if error:
return {'message': REQUEST_NOT_VALID}, HTTPStatus.BAD_REQUEST
if not data.get('email') or not data.get('password'):
return {'message': REQUEST_NOT_VALID}, HTTPStatus.BAD_REQUEST
user = UserModel.query.filter_by(email=data.get('email')).first()
def put(self, user_id):
schema = UserSchema(partial=True)
user = User.query.filter_by(id=user_id).first_or_404()
user = schema.load(request.json, instance=user)
db.session.commit()
return {"User updated": schema.dump(user)}
from sqlalchemy.exc import IntegrityError
from <%= app_name %>.core import jwt_required, doc, use_kwargs, marshal_with
from <%= app_name %>.core.database import db, atomic
from <%= app_name %>.models import User
from <%= app_name %>.schemas import UserSchema
bp = Blueprint('user', __name__)
@doc(tags=['User'], description='list users')
@bp.route('/users', methods=['GET'], provide_automatic_options=False)
@jwt_required
@marshal_with(UserSchema(many=True), code=200)
def index():
users = User.query.all()
return users
@doc(tags=['User'], description='create user')
@bp.route('/users', methods=['POST'], provide_automatic_options=False)
@use_kwargs(UserSchema)
@marshal_with(UserSchema, code=201)
def create(username, email, password):
user = User.create(username=username, email=email, password=password)
return user, 201
@doc(tags=['User'], description='show user')
def get(self, user_id):
schema = UserSchema()
user = User.query.get_or_404(user_id)
return {"user": schema.dump(user)}
def post(self):
schema = UserSchema(partial=True)
user = schema.load(request.json)
db.session.add(user)
db.session.commit()
return {"User created": schema.dump(user)}
def get(self):
schema = UserSchema(many=True)
query = User.query
return paginate(query, schema)
from sanic.exceptions import abort
from sanic.response import json as sanic_json
from sanic.views import HTTPMethodView
from asyncpg.exceptions import DataError
from marshmallow.exceptions import ValidationError
from {{cookiecutter.app_name}}.models.user import User
from {{cookiecutter.app_name}}.schemas.user import UserSchema
schema = UserSchema()
class UsersView(HTTPMethodView):
# noinspection PyMethodMayBeStatic
async def get(self, _):
""" List of users. """
users = await User.query.gino.all()
return sanic_json([user.to_dict() for user in users], 200)
# noinspection PyMethodMayBeStatic
async def post(self, request):
""" Create a new user. """
user = {}
try:
data = schema.load(request.json)
user = (await User.create(**data)).to_dict()
except (ValidationError, DataError) as e:
abort(400, message=e)
return sanic_json(user, 201)
def get(self):
schema = UserSchema(many=True)
query = User.query
data = {"data": paginate(query, schema)}
return status_code.SUCCESS.set_data(paginate(query, schema)).d, 200