def create_user(app):
"""
tool fuction for create test user
"""
user = UserSchema().load(USERDATA)
with app.app_context():
user.save()
print(user)
return user
def getUserList():
users = User.getUserList()
user_schema = UserSchema(many=True)
return make_response(
jsonify({
'code': 200,
'users': user_schema.dump(users).data
}))
def get(self, username: str):
"""
get user info by username
"""
user = User.get_by_username(username)
if not user:
return {'message': 'user do not exist'}, HTTPStatus.BAD_REQUEST
if user.id == get_jwt_identity():
ret = UserSchema(exclude=('created_at', 'updated_at',
'is_activate')).dump(user)
else:
ret = UserSchema(exclude=('created_at', 'updated_at',
'is_activate', 'email')).dump(user)
return ret, HTTPStatus.OK
def signin():
user_schema = UserSchema()
data = request.get_json()
email = data.get('email')
password = data.get('password')
if not email:
return jsonify({'error': 'no credentials provided'}), 400
user = User.query.filter_by(email=email).first()
isAuthenticated = user.check_password(password) if user else False
if isAuthenticated:
# Send the marshmallow serialized object back
output = user_schema.dump(user)
return jsonify({"user": output})
else:
return jsonify({"error": "not a user"})
class UserList(Resource):
"""
user list get api
"""
user_schema = UserSchema()
@swag_from(os.path.join(BASE_DIR, 'docs/user/user_sign_up.yml'),
methods=['post'])
def post(self):
"""
user sign in api and send email
"""
data = request.get_json()
user = mash_load_validate(self.user_schema, data)
ret = UserSchema(exclude=('created_at', 'updated_at',
'is_activate')).dump(user.save())
token = generate_token(user.email, salt='activate')
subject = 'Please confirm your registration'
link = url_for('user_route.useractivateresource',
token=token,
_external=True)
text = 'Hi, Thanks for using multimedia manager! Please confirm your registration\
by clicking on the link: {}'.format(link)
send_mail.delay(subject=subject,
sender='*****@*****.**',
recipients=[user.email],
text=text)
# current_app.logger.info('user %s send activate email successfully', user.username)
return ret, HTTPStatus.CREATED
def registUser():
# jsonデータを取得する
jsonData = json.dumps(request.json)
userData = json.loads(jsonData)
user = User.registUser(userData)
user_schema = UserSchema(many=True)
return make_response(jsonify({'code': 200, 'user': user}))
class UserAvatarResource(Resource):
"""
user avatar api
"""
avatar_schema = AvatarSchema()
user_schema = UserSchema()
storage_path = os.path.join('{storage_path}', 'users', '{username}')
@jwt_required
def put(self):
"""
modify user avatar api
"""
raw_data = request.get_json()
data = mash_load_validate(self.avatar_schema, raw_data)
user = User.query.filter_by(id=get_jwt_identity()).first()
origin_avatar = user.avatar_image
storage_path = self.storage_path.format(
storage_path=current_app.config.get('FILE_STORAGE_PATH'),
username=user.username)
self.save_image(data['file_name'], data['image_name'], storage_path)
user.avatar_image = data['image_name']
user.save()
self.delete_avatar(origin_avatar, storage_path)
ret = self.user_schema.dump(user)
return ret, HTTPStatus.OK
@classmethod
def delete_avatar(cls, image_name: str, storage_path: str):
"""
delete user's avatar
"""
if image_name:
avatar_path = os.path.join(storage_path, image_name)
os.remove(avatar_path)
@classmethod
def save_image(cls, file_name: str, image_name: str, storage_path: str):
"""
rename file name and save it to user's specified path
"""
source_path = os.path.join(current_app.config['UPLOAD_FOLDER'],
file_name)
obj_path = os.path.join(storage_path, image_name)
pathlib.Path(storage_path).\
mkdir(parents=True, exist_ok=True)
shutil.move(source_path, obj_path)
class User(Resource):
schema = UserSchema()
def get(self, id):
user = UserModel.query.get(id)
return self.schema.dump(user).data
def post(self):
params = request.get_json()
deserialized = self.schema.load(params).data
print('deserialized: {}'.format(deserialized))
db.session.add(deserialized)
db.session.commit()
return self.schema.dump(deserialized)
from flask import Flask, request, jsonify, flash, redirect, url_for
from api import app, db
from api.models import User, UserSchema, Clothing, ClothingSchema, Matches, MatchesSchema, Outfit, Favorite, FavoriteSchema, OutfitSchema, Review, ReviewSchema
from flask_login import current_user, login_user, logout_user, login_required
from werkzeug.urls import url_parse
import random
# Init schema
user_schema = UserSchema()
clothing_schema = ClothingSchema()
match_schema = MatchesSchema()
outfit_schema = OutfitSchema()
review_schema = ReviewSchema()
favorite_schema = FavoriteSchema()
users_schema = UserSchema(many=True)
clothings_schema = ClothingSchema(many=True)
matches_schema = MatchesSchema(many=True)
outfits_schema = OutfitSchema(many=True)
reviews_schema = ReviewSchema(many=True)
favorites_schema = FavoriteSchema(many=True)
@app.route('/')
def index():
return 'index'
########## USERS ##########
# POST: Create a user
def get_users(id):
users = User.query.get(id)
users_schema = UserSchema()
output = users_schema.dump(users)
return jsonify({"Result": output})
from flask import Flask, jsonify, request, make_response, Blueprint
from api.middlewares import requires_auth, check_permission_callback, action_callback
from api.models import UserSchema, BoardSchema, CommentSchema
from api import db as database
from api.db import db as redis
mod = Blueprint('views', __name__)
user_schema = UserSchema()
board_schema = BoardSchema()
comment_schema = CommentSchema()
@mod.route('/', methods=['GET'])
@requires_auth
def index():
boards = database.get_boards()
return make_response(jsonify(boards), 200)
@mod.route('/<board_id>', methods=['GET'])
@requires_auth
def single_board(board_id):
board = database.get_board(board_id)
if board is None:
return jsonify({'message': 'Board is not present'}, 404)
else:
return make_response(jsonify(board), 200)
@mod.route('/sign_up', methods=['POST'])
def users():
users = User.query.all()
user_schema = UserSchema(many=True)
output = user_schema.dump(users)
return jsonify({"users": output})