from flask_restx import Namespace, Resource, fields
from flask_jwt_extended import jwt_required, get_jwt_identity
from flask import request
from models.user import UserModel
from schemas.user import UserSchema
from user_functions.record_user_log import record_user_log
api = Namespace('update', description='Update User')
user_schema = UserSchema()
users_schema = UserSchema(many=True)
user_model = api.model('User', {
'full_name': fields.String(required=True, description='Full Name'),
'email': fields.String(required=True, description='Email'),
'phone': fields.String(required=True, description='Phone'),
})
@api.route('/<int:id>')
@api.param('id', 'The user identifier')
class UpdateUser(Resource):
@api.doc('Update user')
@api.expect(user_model)
@jwt_required
def put(self,id:int):
'''Update User'''
try:
my_user = UserModel.fetch_by_id(id)
user = user_schema.dump(my_user)
if len(user) == 0:
from models.user import UserModel
from schemas.user import UserSchema
from blacklist import BLACKLIST
ERROR_BLANK = " '{}' field cannot be blank"
ERROR_INSERTING = "An error occurred inserting the song"
ERROR_USER_ALREADY_EXISTS = "An user with name '{}' already exist"
ERROR_USER_NOT_FOUND = "Tuning not found"
ERROR_INVALID_CREDENTIALS = "Invalid credentials"
MESSAGE_TUNNING_DELETED = "Tuning deleted"
MESSAGE_USER_CREATED = "User create successfully"
MESSAGE_USER_LOGGED_IN = "Login successfully"
MESSAGE_USER_LOGGED_OUT = "User <id={}> logged out"
MESSAGE_USER_DELETED = "User has been removed"
user_schema = UserSchema()
class UserRegister(Resource):
@classmethod
def post(cls):
try:
user = user_schema.load(request.get_json())
except ValidationError as err:
return err.messages, 400
if UserModel.find_by_username(user.username):
return ({"error": ERROR_USER_ALREADY_EXISTS.format(user.username)}, 400)
user.save_to_db()
from flask import request
from flask_restful import Resource
from http import HTTPStatus
from utils import hash_password, save_image
from models.user import User
from flask_jwt_extended import jwt_optional, get_jwt_identity, jwt_required, fresh_jwt_required
from schemas.user import UserSchema
from resources.util import user_not_found, item_not_found
from extensions import image_set
import os
user_schema = UserSchema()
user_public_schema = UserSchema(exclude=(
"email",
"created_at",
"updated_at",
))
user_profile_picture_schema = UserSchema(only=("profile_picture", ))
class UserListResource(Resource): #Käyttäjän teko
def post(self):
json_data = request.get_json()
data, errors = user_schema.load(data=json_data)
if errors:
return {
"message": "Validation errors",
"errors": errors
}, HTTPStatus.BAD_REQUEST
from flask import request
from flask_jwt_extended import get_jwt_identity, jwt_optional, jwt_required
from flask_restful import Resource
from http import HTTPStatus
from marshmallow import ValidationError
from models.user import User
from schemas.user import UserSchema
user_schema = UserSchema()
user_public_schema = UserSchema(exclude=('email', ))
class UserListResource(Resource):
def post(self):
json_data = request.get_json()
try:
data = user_schema.load(data=json_data)
except ValidationError as errors:
return {
'message': 'Validation errors',
'errors': errors.messages
}, HTTPStatus.BAD_REQUEST
if User.get_by_username(data.get('username')):
return {'message': 'username already used'}, HTTPStatus.BAD_REQUEST
if User.get_by_email(data.get('email')):
return {'message': 'email already used'}, HTTPStatus.BAD_REQUEST
user = User(**data)
def get(cls):
user_id = get_jwt_identity()
user = UserModel.find_by_id(user_id)
if not user:
return max_err(USER_NOT_FOUND, 404)
return max_res(UserSchema().dump(user))
from extensions import image_set, limiter
from mailgun import MailgunApi
from models.user import User
from models.recipe import Recipe
from schemas.recipe import RecipeSchema, RecipePaginationSchema
from schemas.user import UserSchema
from utils import generate_token, verify_token, save_image, clear_cache
from webargs import fields
from webargs.flaskparser import use_kwargs
user_schema = UserSchema()
user_avatar_schema = UserSchema(only=('avatar_url',))
user_public_schema = UserSchema(exclude=('email',))
recipe_list_schema = RecipeSchema(many=True)
recipe_pagination_schema = RecipePaginationSchema()
# This data is stored in the environment variable. First, you should ensure of
# creating an account with Mailgun, then generate the API_KEY and API_URL,
# and add both to the environment variable.
mailgun = MailgunApi(
domain=os.environ.get('MAILGUN_DOMAIN'),
api_key=os.environ.get('MAILGUN_API_KEY'))
# Create a dictionary for API pagination. The key-value pairs are passed to the
# @use_kwargs decorator
pages = {
from schemas.user import UserSchema
from blacklist import BLACKLIST
USER_ALREADY_EXISTS = "A user with that username already exists."
CREATED_SUCCESSFULLY = "User created successfully. Confirmation email was sent."
USER_NOT_FOUND = "User not found."
USER_DELETED = "User deleted."
INVALID_CREDENTIALS = "Invalid credentials!"
USER_LOGGED_OUT = "User <id={user_id}> successfully logged out."
NOT_CONFIRMED_ERROR = (
"You have not confirmed registration, please check your email <{}>."
)
NOT_ACTIVATED = "Not activated"
ACTIVATED = "Is activated"
user_schema = UserSchema(unknown=EXCLUDE)
class UserRegister(Resource):
@classmethod
def post(cls):
user_json = request.get_json()
user = user_schema.load(user_json)
if UserModel.find_by_username(user.username):
return {"message": USER_ALREADY_EXISTS}, 400
if UserModel.find_by_email(user.email):
return {"message": USER_ALREADY_EXISTS}, 400
user.save_to_db()
import traceback
import datetime
from flask_restful import Resource, reqparse
from flask import request
from werkzeug.security import safe_str_cmp
from flask_jwt_extended import create_access_token, jwt_refresh_token_required, create_refresh_token, get_jwt_identity, jwt_required, get_raw_jwt
from schemas.user import UserSchema
from models.user import UserModel
from models.confirmation import ConfirmationModel
user_schema = UserSchema()
user_list_schema = UserSchema(many=True)
class UserRegister(Resource):
@classmethod
def post(cls):
user = user_schema.load(request.get_json())
if UserModel.find_by_email(user.email):
return {"message": "Email already exist"}, 400
if UserModel.find_by_contact(user.contact):
return {"message": "contact already registered"}, 400
try:
user.save_to_db()
confirmation = ConfirmationModel(user.id)
confirmation.confirmed = True
confirmation.save_to_db()
def create_user(user: UserSchema, db: Session):
db_user = models.User(**user.dict())
db.add(db_user)
db.commit()
db.refresh(db_user)
return db_user
from flask_restplus import Api, Resource
from github import Github
from marshmallow import ValidationError
from main import app, db
from schemas.user import UserSchema
from flask_script import Manager
from models.user import *
api = Api(app)
migrate = Migrate(app, db)
manager = Manager(app)
manager.add_command('db', MigrateCommand)
user = User.query.all()
schema_get = UserSchema(many=True)
schema_post = UserSchema()
@api.route('/users')
class UsersView(Resource):
def get(self):
return schema_get.dump(user)
def post(self):
user_details = request.get_json()
try:
clean_data = schema_post.load(user_details)
data = User(**clean_data)
db_response = data.save()
response = schema_post.dump(db_response)
from flask import request
from flask_restful import Resource
from flask_jwt_extended import get_jwt_identity, jwt_required
from http import HTTPStatus
from marshmallow import EXCLUDE
from utils import check_admin, check_email
from models.user import User
from schemas.user import UserSchema
from schemas.find_user import UserInfoSchema
user_schema = UserSchema()
user_schema_noadm = UserSchema(exclude=("is_admin", ))
user_schema_outsider = UserSchema(exclude=("is_turkuamk", "is_admin"))
class UserResource(Resource):
def post(self):
json_data = request.get_json()
data = user_schema.load(json_data)
admin = check_admin(data.get("admin_pass"))
data = UserSchema(unknown=EXCLUDE).load(json_data)
if User.get_by_username(data.get("username")) or User.get_by_email(
data.get("email")):
return {
"message": "Username or email already taken"
}, HTTPStatus.BAD_REQUEST
if admin and check_email(data.get("email")):
