def put_user():
schema = UserSchema()
result = dict()
if not request.is_json:
result['msg'] = 'Missing JSON in request'
return jsonify(result), 400
req_data = request.get_json()
if 'email' in req_data.keys():
email = req_data['email']
user = User.query.get_or_404(email)
if 'password' in req_data.keys():
user.password = req_data['password']
if 'name' in req_data.keys():
user.name = req_data['name']
db.session.add(user)
db.session.commit()
result['msg'] = 'OK'
result['data'] = schema.dump(user)
else:
result['msg'] = 'keys error'
return jsonify(result), 400
return jsonify(result), 200
def create_user():
from wsgi import bcrypt
schema = UserSchema()
result = dict()
req_data = request.get_json()
if 'email' in req_data.keys():
email = req_data['email']
user = User.query.get(email)
if user is None:
user = User()
user.email = req_data['email']
if 'password' in req_data.keys():
password = req_data['password']
pw_hash = bcrypt.generate_password_hash(password)
user.password = pw_hash
if 'name' in req_data.keys():
user.name = req_data['name']
else:
# TODO 존재하면 있다고 리턴
result['msg'] = 'user exists'
return jsonify(result), 400
else:
user = schema.load(request.json)
db.session.add(user)
db.session.commit()
result['msg'] = "user created"
# result['data'] = schema.dump(user)
result['data'] = "OK"
return jsonify(result)
def get(self):
users_schema = UserSchema(many=True)
try:
users = User.retrieve_all()
except Exception as e:
return jsonify(error=str(e))
else:
return users_schema.jsonify(users).json, 200
def get(self, user_id):
user_schema = UserSchema(exclude=['password'])
users = User.query.get(user_id)
if not users:
return {'status': 'error', 'data': 'not found'}, 404
print(users.image)
users = user_schema.dump(users)
return {'status': 'ok', 'data': users}, 200
def insert_user(user_json):
user = UserSchema().load(user_json)
try:
user.password = user_service.set_user_password(user.password)
return user_service.insert_user(user)
except Exception as e:
print(e)
return {'error': 'Falha ao inserir usuario'}, 500
def list_users():
from wsgi import app
app.logger.info("users call")
schema = UserSchema(many=True)
all_Users = User.query
result = dict()
result['data'] = schema.dump(all_Users)
return jsonify(result)
def list_users():
search = request.args.get('keyword', '')
schema = UserSchema(many=True)
if search:
users = User.query.filter(User.username.ilike('%{}%'.format(search)))
return jsonify(schema.dump(users)), 200
users = User.query.all()
return jsonify(schema.dump(users)), 200
def get_user(email):
schema = UserSchema()
result = dict()
user = User.query.get_or_404(email)
result['msg'] = 'OK'
result['data'] = schema.dump(user)
return jsonify(result), 200
def get_by_id(user_id):
try:
item = UserModel.query.filter_by(id=user_id).first()
if item is None:
return HTTP_404_NOT_FOUND, None
schema = UserSchema()
result = schema.dump(item, many=False)
return HTTP_200_OK, result
except Exception as error:
print("Error------------------", error)
return HTTP_400_BAD_REQUEST, None
def get(self, id):
user_schema = UserSchema()
try:
data = {'id': id}
user = User.retrieve_by(**data)
if not user:
raise Exception(f'There are not user ID {id}')
except Exception as e:
return jsonify(error=str(e))
else:
return user_schema.jsonify(user).json, 200
def post(self):
user_schema = UserSchema()
try:
data_json = request.json
if not data_json:
raise Exception('The request does not have json data.')
user = User.create(**data_json)
except Exception as e:
return jsonify(error=str(e))
else:
return user_schema.jsonify(user).json, 201
def put(self, user_id):
try:
req_data = request.get_json(force=True)
user_in_db = User.get_user_by_id(user_id)
if not user_in_db:
return bad_request('User not found!', 422)
data = UserSchema().load(req_data, partial=True)
db_helper.update(user_in_db, data)
data = UserSchema(exclude=['password']).dump(user_in_db)
return ok(data, 200)
except ValidationError as e:
return bad_request(e.messages, 422)
except Exception as e:
print(e)
return bad_request('Something went wrong', 500)
def create(user_data):
try:
schema = UserSchema()
new_item = schema.make(user_data)
new_item.password = lazy_hashing(user_data['password'])
db.session.add(new_item)
# commit
db.session.commit()
# dump data
result = schema.dump(new_item, many=False)
print("items-------------", result)
return HTTP_201_CREATED, result
except Exception as error:
print("Error----------------", error)
db.session.rollback()
return HTTP_400_BAD_REQUEST, None
def create_user():
username = request.json.get('username')
password = request.json.get('password')
if not username or not password:
return jsonify({
"Error": [{
"Type": "I/O",
"message_error": "password or username is not inserted"
}]
}), 400
if User.query.filter_by(username=username).first():
return jsonify({
"Error": [{
"Type": "business",
"message_error": "this username is not exist"
}]
}), 400
user = User(username=username)
user.hashed_password = user.hash_password(password)
db.session.add(user)
db.session.commit()
return jsonify(UserSchema().dump(user)), 201
def on_get(self, req, resp, user_id):
query = req.context['session'].query(UserModel)
query = query.filter(UserModel.id == user_id)
user = query.one_or_none()
if not user:
raise falcon.HTTPNotFound()
resp.body = json.dumps(UserSchema().dump(user).data)
def get_all(page_number, page_size):
# return http_status, data, total
try:
schema = UserSchema()
total = UserModel.query.count()
if total == 0:
return HTTP_404_NOT_FOUND, None, 0
items = UserModel.query.paginate(page_number, page_size).items
if items in [None, {}]:
return HTTP_404_NOT_FOUND, None, 0
# dump data
result = schema.dump(items, many=True)
return HTTP_200_OK, result, total
except Exception as error:
print("Error----------------", error)
return HTTP_400_BAD_REQUEST, None, 0
def patch(self, user_id):
try:
data_parser = parser.parse_args()
users = User.get_user_by_id(user_id)
if not users:
return bad_request('User not found!', 422)
if data_parser['file'] == "":
return bad_request('File not found!', 422)
photo = data_parser['file']
if photo and allowed_file(photo.filename):
secure_name = secure_filename(photo.filename)
secure_name = get_file_extension(secure_name)
secure_name = '{}{:-%Y%m%d%H%M%S}.{}'.format(
str(uuid4().hex), datetime.now(), secure_name)
photo.save(os.path.join(APP_STATIC, secure_name))
if users.image:
os.remove(os.path.join(APP_STATIC, users.image))
# photo_url = request.url_root + url_for(
# 'static', filename="image/" + secure_name)
users.image = secure_name
users.updated_at = datetime.now()
db_helper.only_save()
users = UserSchema(exclude=['password']).dump(users)
return ok(users, 200)
else:
return bad_request('File not allowed!', 422)
except Exception as e:
return bad_request('Something went wrong', 500)
def post(self):
try:
json_data = request.get_json(force=True)
if not json_data:
return bad_request('No input data provided', 400)
if 'email' not in request.json:
return bad_request('email not provided', 422)
if 'password' not in request.json:
return bad_request('password not provided', 422)
if json_data['email'] == '' or json_data['email'] == None:
return bad_request('email can\'t be empty or null', 422)
if json_data['password'] == '' or json_data['password'] == None:
return bad_request('password can\'t be empty or null', 422)
user_in_db = User.get_user_by_email(json_data['email'])
if user_in_db:
authorized = user_in_db.check_password(json_data['password'])
if authorized:
users = UserSchema(only=('id', 'name',
'roles')).dump(user_in_db)
expires = timedelta(days=1)
token = create_access_token(identity=users,
expires_delta=expires)
return ok(
{
'id': users['id'],
'name': users['name'],
'token': token
}, 200)
else:
return bad_request('wrong password', 422)
else:
return bad_request('user not found!', 404)
except Exception as e:
return bad_request(str(e), 500)
def _update_user(user_id):
form = UserSchema().validate_or_400(request.get_json())
user = User.get(user_id)
user = user.update(form)
if commit_to_db():
return success(user.json())
error(500, {"user": "******"})
def post(self):
json_data = request.get_json(force=True)
if not json_data:
return bad_request('No input data provided', 400)
try:
data = UserSchema().load(json_data)
user_in_db = User.get_user_by_email(data.get('email'))
if user_in_db:
return bad_request('User already exist, please supply another email address', 422)
users = User(data)
db_helper.insert(users)
ser_data = UserSchema(exclude=['password']).dump(users)
return ok(ser_data, 201)
except ValidationError as e:
return bad_request(e.messages, 422)
except Exception:
return bad_request('Something went wrong', 500)
def login( email, password ):
user = get_user_by_email( email )
if validate_user_password( password, user.password ):
user.password = None
return UserSchema().dump( user ), 200
else:
raise Exception("Senha incorreta!")
def update(user_id, user_data):
try:
schema = UserSchema()
item = UserModel.query.filter_by(id=user_id).first()
print(item)
if item is None:
return HTTP_404_NOT_FOUND, None
if user_data.get('password') is not None:
user_data['password'] = lazy_hashing(user_data['password'])
new_item = UserModel.query.filter_by(id=user_id).update(user_data)
db.session.commit()
item = UserModel.query.filter_by(id=user_id).first()
result = schema.dump(item, many=False)
return HTTP_201_CREATED, result
except Exception as error:
print("Error-------------", error)
db.session.rollback()
return HTTP_400_BAD_REQUEST, None
def post(self):
"""
Check if the user exists and if their email has been confirmed.
Check the password and if correct returns an auth cookie.
For auth we only need the email and password to identify a user.
"""
user_schema = UserSchema(only=["email", "password"])
form = user_schema.validate_or_400(request.get_json())
user = User.query.filter_by(email=form["email"]).first()
# Check the email and password are correct.
if not user or not user.check_password(form["password"]):
fail(401, {"form": "Incorrect email address or password"})
# Check the user has confirmed their email.
if not user.confirmed_on:
fail(401, {"form": "Please confirm email"})
return _login_success_response(user)
def login(auth_payload):
"""
API: POST /authenticate
"""
username = auth_payload['username']
password = auth_payload['password']
user = UserModel.query.filter_by(
username=username,
password=lazy_hashing(password)) \
.first()
print("User::User==============", user)
if user is not None:
schema = UserSchema()
# dump data
result = schema.dump(user, many=False)
return send_response(code=200, data=result)
else:
return send_response(code=400, message="Sai tài khoản hoặc mật khẩu")
def put(self, id):
user_schema = UserSchema()
try:
data = {'id': id}
user = User.retrieve_by(**data)
if not user:
raise Exception(f'There are not user ID {id}')
data_json = request.json
if not data_json:
raise Exception('The request does not have json data.')
user.update(**data_json)
except Exception as e:
return jsonify(error=str(e))
else:
return user_schema.jsonify(user).json, 200
def get_user(current_user, public_id):
if not current_user.admin:
return jsonify({'message': 'Cannot perform that function!'})
user = User.query.filter_by(public_id=public_id).first()
if not user:
return jsonify({'message': 'No user found'})
return UserSchema().jsonify(user)
def register(user_data):
try:
schema = UserSchema()
new_item = schema.make(user_data)
new_item.password = lazy_hashing(user_data['password'])
new_item.role = 1
new_item.danger = False
new_item.point = 0
new_item.status = 1
new_item.member_id = 0
db.session.add(new_item)
# commit
db.session.commit()
# dump data
result = schema.dump(new_item, many=False)
print("items-------------", result)
return HTTP_201_CREATED, result
except Exception as error:
print("Error----------------", error)
db.session.rollback()
return HTTP_400_BAD_REQUEST, None
def get_sort_by():
"""
Return the string for sqlalchemy to use for order_by from query_params.
"""
sort_by = snakecase(request.args.get("sortby", "id"))
if sort_by not in UserSchema().field_names():
fail(400, {"sortby": "Sortby is not a valid field for resource"})
order = request.args.get("order", "asc").lower()
if order not in ["asc", "desc"]:
fail(400, {"order": "Order must be asc or desc"})
return sql.text(f"{sort_by} {order}")
def update_user(id):
user = User.query.get_or_404(id)
username = request.json.get('username')
password = request.json.get('password')
if username and user.username != username:
duplicate = User.query.filter_by(username=username).first()
if duplicate:
return jsonify(message_code=1007), 409
user.username = username
db.session.commit()
return jsonify(UserSchema().dump(user)), 200
def post(self):
"""
Check that the username and email are not already in use by another
user and check the password strength is sufficient as the average user
will need this check. If this is successful then create the user.
"""
form = UserSchema().validate_or_400(request.get_json())
user = User.create(form)
user.set_role(Roles.user)
if commit_to_db():
user.send_confirmation_email()
return success({"confirm": "Please confirm email address"})
error(500, {"user": "******"})
