def authenticate_user(db, document: str, password: str):
user = get_user(db, document, password)
user_dict = UserSchema.from_orm(user).dict()
user = UserInDB(**user_dict)
logger.debug(f"{user} ")
if not user:
return False
return user
def post(self):
data = request.get_json(force=True)
user_schema = UserSchema()
result = user_schema.load(data)
if result.errors:
return response.error(result.errors, 400)
for user in User.get_all(): # check if user already exist
if user.email == data['email']:
return response.error('User already exist', 409)
# hash password and create a new user
hashed_password = generate_password_hash(data['password'],
method='sha256')
new_user_obj = User(data['name'], data['email'], hashed_password)
new_user_obj.save()
# format and display user information
user_schema = UserSchema(exclude=['password'])
new_user = user_schema.dump(data)
res, code = response.success('User created', new_user.data, 201)
res.update(
{'token': create_access_token(identity=new_user.data['email'])})
return res, code
def post(self):
data = request.get_json(force=True)
user_schema = UserSchema(only=['email', 'password'])
result = user_schema.load(data)
if result.errors:
return response.error(result.errors, 400)
current_user = None
for user in User.get_all():
if user.email == data['email']:
current_user = user
break
if not current_user:
return response.error('User not found, Login unsuccessful', 403)
if check_password_hash(current_user.password, data['password']):
user_schema = UserSchema(exclude=['password'])
active_user = user_schema.dump(current_user)
res, code = response.success('Login successful', active_user.data,
200)
res.update({
'token':
create_access_token(identity=active_user.data['email'])
})
return res, code
return response.error('Wrong credentials', 401)
class PublishSchema(Schema):
regex_for_published_date = r"Jan?|Feb?|Mar?|Apr?|May|Jun?|Jul?|Aug?|Sep?|Oct?|Nov?|Dec?\s+\d{1,2}"
regex_for_path = r"^(.+)\/([^/]+)$"
user_schema = UserSchema()
type_of = fields.Str(
required=True,
allow_none=False,
)
id = fields.Int(
required=True,
allow_none=False,
)
title = fields.Str(required=True, allow_none=False)
description = fields.Str(required=True, allow_none=False)
readable_publish_date = fields.Str(
required=True,
allow_none=False,
validate=validate.Regexp(regex_for_published_date))
slug = fields.Str(
required=True,
allow_none=False,
)
path = fields.Str(required=True,
allow_none=False,
validate=validate.Regexp(regex_for_path))
url = fields.Str(
required=True,
allow_none=False,
validate=validate.URL(error="Not a valid URL for url field"))
comments_count = fields.Int(required=True, allow_none=False)
positive_reactions_count = fields.Int(required=True, allow_none=False)
collection_id = fields.Int(required=True, allow_none=True)
published_timestamp = fields.DateTime(required=True, allow_none=False)
cover_image = fields.URL(required=True, allow_none=True)
social_image = fields.URL(required=True)
canonical_url = fields.URL(required=True)
created_at = fields.DateTime(required=True, allow_none=False)
edited_at = fields.DateTime(required=True, allow_none=True)
crossposted_at = fields.DateTime(required=True, allow_none=True)
published_at = fields.DateTime(required=True, allow_none=False)
last_comment_at = fields.DateTime(required=True, allow_none=True)
tag_list = fields.List(fields.Str, required=True, allow_none=True)
tags = fields.Str(required=True, allow_none=True)
user = fields.Nested(user_schema)
from flask import Flask, request, jsonify
from models.user import User, db
from schemas.user_schema import UserSchema, ma
app = Flask(__name__)
db.init_app(app)
ma.init_app(app)
basedir = os.path.abspath(os.path.dirname(__file__))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(
basedir, 'crud.sqlite')
# db.create_all('__all__', app)
user_schema = UserSchema()
users_schema = UserSchema(many=True)
# endpoint to create new user
@app.route("/user", methods=["POST"])
def add_user():
username = request.json['username']
email = request.json['email']
new_user = User(username, email)
db.session.add(new_user)
db.session.commit()
return jsonify('{ok: ok}')
from flask_restful import Resource
from flask import request
from models.user_model import UserModel
from schemas.user_schema import UserSchema
from marshmallow import ValidationError
user_schema = UserSchema()
class UserRegister(Resource):
def post(self):
try:
user = user_schema.load(request.get_json())
except ValidationError as err:
return err.messages, 400
if UserModel.find_by_username(user.username):
return {"message": "User already exists"}, 400
user.save_to_db()
return {"message": "User created successfully"}, 201
class User(Resource):
@classmethod
def get(cls, user_id: int):
user = UserModel.find_by_id(user_id)
from collections import Counter
from flask_restful import Resource
from flask import request
from marshmallow import ValidationError
from werkzeug.security import safe_str_cmp
from flask_jwt_extended import create_access_token, create_refresh_token
from models.user_model import UserModel, UserRoleMapper
from schemas.user_schema import UserSchema
user_schema = UserSchema()
users_schema = UserSchema()
class UserManagement(Resource):
def post(self):
roles = []
user_data = request.get_json()
if UserModel.find_by_username(user_data["username"]):
return {"message": "A user with that username already exists"}, 400
roles_list = Counter(user_data['roles'])
for _id in roles_list:
roles.append(UserRoleMapper(role_id=_id))
user = UserModel(roles=roles)
user.save_to_db()
return {"message": "User created successfully."}, 201
def get_user_login(db: Session, document:str):
user = db.query(User).filter_by(document = document).first()
return UserSchema.from_orm(user)