Example #1
0
    def get(self,uid):

        user = User.query.filter_by(uid=uid).first()
        schema = UserSchema()
        if user is not None:
            return Response(schema.dumps(user,indent=1).data,mimetype='application/json'),201
        return jsonify({"get":"fail"})
Example #2
0
 def post(self):
     data = request.get_json() or {}
     user = UserSchema.model_validate(data)
     if user:
         user.save()
         return 'User created', 200
     return 'User error', 409
Example #3
0
def register():
    data = request.json
    schema = UserSchema()

    try:
        user = schema.load(data)
    except ValidationError as error:
        return error.messages

    try:
        user_exists = User.select().where(User.email == user.email).get()
        return response_data(409, 'Already exists an user with that email')
    except peewee.DoesNotExist:
        pass

    password = user.password.encode()
    user.password = bcrypt.hashpw(password, bcrypt.gensalt())
    user.save()

    return response_data(200, 'User registered')
class UserService:
    def __init__(self):
        self.anonymous_email = "*****@*****.**"
        self.anonymous_gaia = "ewpewawn"

        self.user_single = UserSchema()
        self.user_multiple = UserSchema(many=True)

    def serialize_single(self, user):
        return self.user_single.dump(user)

    def serialize_multiple(self, users):
        return self.user_multiple.dump(users)

    def get_or_create(self, email, gaia):
        user = self.get(email)
        if user is not None:
            print("User <'email={0} gaia={1}'> already exists.".format(email, gaia))
            return user

        user = User(email=email, gaia=gaia)
        database.session.add(user)
        database.session.commit()
        return user

    def get(self, email):
        user = User.query.filter_by(email=email).first()
        if user is None:
            print("User <'email={0}'> does not exist yet.".format(email))
            return None
        return user

    def get_all(self):
        return User.query.order_by(User.create_time.desc()).all()

    def get_anonymous(self):
        return self.get_or_create(self.anonymous_email, self.anonymous_gaia)
    def __init__(self):
        self.anonymous_email = "*****@*****.**"
        self.anonymous_gaia = "ewpewawn"

        self.user_single = UserSchema()
        self.user_multiple = UserSchema(many=True)
Example #6
0
 def get(self):
     users = User.query.filter(User.admin == 1).all()
     if users == []:
         return jsonify({'get':'fail'})
     schema = UserSchema(many = True)
     return Response(schema.dumps(users,indent=1).data,mimetype='application/json')
Example #7
0
from flask_jwt_extended import (JWTManager, jwt_required, create_access_token,
                                get_jwt_identity)
jwt = JWTManager(app)
app.config["JSONIFY_PRETTYPRINT_REGULAR"] = False
app.config['SECRET_KEY'] = 'some-secret-string'
app.config['JWT_SECRET_KEY'] = 'super-secret'

# reszta importóww
from models import User, Post
from flask_restful import Api
from serializers import UserSchema, PostSchema
from werkzeug.security import generate_password_hash, \
     check_password_hash

user_schema = UserSchema()
users_schema = UserSchema(many=True)
post_schema = PostSchema()
posts_schema = PostSchema(many=True)


#custom error
# @app.errorhandler(404)
# def page_not_found(e):
#     return "error 404"
@app.route('/')
def index():
    # abort(404)
    return jsonify({"msg": "Hello Api"})

Example #8
0
def api_login(email, password):

    user = User.query.filter_by(email=email).one_or_none()

    if user is not None and check_password_hash(user.password, password):
        user.update(last_login_at=datetime.now())
        token = create_access_token(identity=user.id)
        return jsonify({'status': 200, 'access_token': token})

    return jsonify({'status': 404, 'message': 'not found your email'})


@blueprint.route('/api/users', methods=['POST'])
@jwt_optional
@use_kwargs(CreateUserSchema())
@marshal_with(UserSchema())
def create(email, name, password, **kwargs):

    if User.query.filter_by(email=email).one_or_none() is None:
        user = User(
            email=email,
            name=name,
            password=generate_password_hash(password)
        ).save()
        return user
    else:
        return jsonify({'status': 500, 'message': 'email has exists'})


@blueprint.route('/api/users', methods=['GET'])
@jwt_required