def create_user(): try: user_info = google_auth.get_user_info() user = User.query.filter_by(user_name=user_info['name']).first() if user: message = "User already exists" user_schema = UserSchema() data = user_schema.dump(user).data session['user'] = data return send_success_response(message) if user_info['email'] == "*****@*****.**": user = User(user_name=user_info['name'], user_email=user_info['email'], is_admin=True) else: user = User(user_name=user_info['name'], user_email=user_info['email']) db.session.add(user) db.session.commit() user_schema = UserSchema() data = user_schema.dump(user).data session['user'] = data message = "User created successfully" return send_success_response(message) except Exception as e: message = "Error in creating user" return send_error_response(str(e))
def create(user): name = user.get("name") login = user.get("login") password = user.get("password") existing_user = (User.query.filter(User.login == login).filter( User.name == name).one_or_none()) if existing_user is None: schema = UserSchema() new_user = User(id=(int(User.query.all()[-1].id) + 1), name=name, login=login, password=password, token=create_token(), expiration=datetime.now()) db.session.add(new_user) db.session.commit() data = schema.dump(new_user).data return data, 201 else: abort(409, f"User was exist")
def update(user_id, user): """ This function updates an existing person in the people structure :param person_id: Id of the person to update in the people structure :param person: person to update :return: updated person structure """ # Get the person requested from the db into session update_user = User.query.filter(User.user_id == user_id).one_or_none() # Did we find an existing person? if update_user is not None: # turn the passed in person into a db object schema = UserSchema() update = schema.load(user, session=db.session).data # Set the id to the person we want to update update.user_id = update_user.user_id # merge the new object into the old and commit it to the db db.session.merge(update) db.session.commit() # return updated person in the response data = schema.dump(update_user).data return data, 200 # Otherwise, nope, didn't find that person else: abort(404, "User not found for Id: {user_id}".format(user_id=user_id))
def read_one(user_name): """ This function responds to a request for /api/user/{user_name} with one matching user from settings :param id_user: Id of user to find :return: user matching id """ # Get the person requested user = User.query.filter(User.user_name == user_name).one_or_none() # Did we find a person? if user is not None: # Serialize the data for the response schema = UserSchema() data = schema.dump(user).data return data # Otherwise, nope, didn't find that person else: abort( 404, "User not found for Id: {user_name}".format(user_name=user_name), )
def create(user): """ This function creates a new person in the people structure based on the passed in person data :param person: person to create in people structure :return: 201 on success, 406 on person exists """ name = User.get("name") existing_user = (User.query.filter(User.name == name).one_or_none()) # Can we insert this person? if existing_user is None: # Create a person instance using the schema and the passed in person schema = UserSchema() new_user = schema.load(user, session=db.session).data # Add the person to the database db.session.add(new_user) db.session.commit() # Serialize and return the newly created person in the response data = schema.dump(new_user).data return data, 201 # Otherwise, nope, person exists already else: abort(409, f"Person {name} exists already")
def view(): if session.get('user'): user_schema = UserSchema() api_ready_data = dict_for_api(user_schema.dump(session.get('user'))) return api_ready_data return {'message': 'User not found'}, 404
def register(): """ Register user :return: """ if request.json['password'] != request.json['passwordVerify']: return { 'message': 'data error', 'errors': { 'password': '******' } }, 400 user = User() user.password = User.hash(request.json['password'].encode('utf-8')) user.email = request.json['email'] user.first_name = request.json['firstName'] user.last_name = request.json['lastName'] db.session.add(user) db.session.commit() user_schema = UserSchema() session['user'] = user_schema.dump(user) return { 'message': 'Check email to validate' }, 200, { 'Access-Control-Allow-Origin': '*' }
def update(oid, userDetails): """ Updates an existing user in the user list. :param id: oid of the user to update in the user list :param user: user to update :return: updated user """ app.logger.debug(pformat(userDetails)) if userDetails.get("id") and userDetails.get("id") != oid: abort(400, f"Id {oid} mismatch in path and body") # Admin rights can't be set via POST nor PUT calls (#303) if "isLZAdmin" or "isMCAdmin" in userDetails: abort(400, "Unable to set admin rights in PUT operation.") # Does the user exist in user list? existing_user = db.session.query(User).filter(User.id == oid).one_or_none() # Does user exist? if existing_user is not None: userDetails["id"] = oid schema = UserSchema() update_user = schema.load(userDetails, session=db.session) db.session.merge(update_user) db.session.commit() # return the updted user in the response data = schema.dump(update_user) return data, 200 # otherwise, nope, deployment doesn't exist, so that's an error return abort(404, f"User {oid} not found")
def create(user): user_name = user.get("user_name") email = user.get("email") token = user.get("user_token") timezone = user.get("timezone") existing_user = (User.query.filter(User.user_name == user_name).filter( User.email == email).one_or_none()) if existing_user is None: new_user = User(user_name, email, token, timezone) db.session.add(new_user) db.session.commit() dump_schema = UserSchema(exclude=["user_token"]) data = dump_schema.dump(new_user) return data, 201 else: abort( 409, "User {user_name} at {email} already exists.".format( user_name=user_name, email=email))
def update(userid, user): update_user = User.query.filter(User.userid == userid).one_or_none() user_name = user.get("user_name") email = user.get("email") existing_user = (User.query.filter(User.user_name == user_name).filter( User.email == email).one_or_none()) if update_user is None: abort(404, "User not found for Id: {}".format(userid)) elif existing_user is not None and existing_user.id != userid: abort( 409, "User {user_name} at {email} already exists".format( user_name=user_name, email=email)) else: schema = UserSchema() update = schema.load(user, session=db.session) update.userid = update_user.userid db.session.merge(update) db.session.commit() data = schema.dump(update_user) return data, 200
def get_all_mentees(): """Return all users who are mentees""" mentee_objects = session.query(Users).filter(Users.is_mentee == True).all() schema = UserSchema(many=True) mentees = schema.dump(mentee_objects) return jsonify(mentees.data)
def read_one_user_by_id(id): user = User.query.get(id) if user is not None: user_schema = UserSchema() return user_schema.dump(user) else: abort(404, f'User not found for id: {id}')
def read_one_by_id(user_id): user = User.query.filter(User.person_id == user_id).one_or_none() if user is not None: user_schema = UserSchema() return user_schema.dump(user) else: abort(404, 'User not found for Id: {user_id}'.format(user_id=user_id))
def read_one(username): user = User.query.filter(User.username == username).one_or_none() if user is not None: user_schema = UserSchema() return user_schema.dump(user) else: abort(404, 'User not found for username: {username}'.format(username=username))
def read_one(user_id): user = (User.query.filter(User.id == user_id).one_or_none()) if user is not None: user_schema = UserSchema() data = user_schema.dump(user).data return data else: abort(404, f"Not found id: {user_id}")
def read_email(user): email = user.get("email") user = User.query.filter(User.email == email).one_or_none() if user is not None: user_schema = UserSchema(exclude=["encoded_password"]) data = user_schema.dump(user) return data, 200 else: abort(404, "User record not found for {}.".format(email))
def read_all(token): user = User.query.filter(User.token == token).one_or_none() if user is not None: users = User.query.order_by(User.id).all() user_schema = UserSchema(many=True) data = user_schema.dump(users).data return data else: abort(403, f"Not allowo")
def user_show(given_token): user = User.query.filter_by(token=given_token).first() print(type(user)) if user is not None: user_schema = UserSchema() res = user_schema.dump(user) print(res) return jsonify({'user': res}), 200 else: return "Not Found", 404
def read_token(user): user_token = user.get("user_token") user = User.query.filter(User.user_token == user_token).one_or_none() if user is not None: user_schema = UserSchema(exclude=["userid", "user_token"]) data = user_schema.dump(user) return data, 200 else: abort(404, "User not found.")
def create(socket_id, name): try: user = User(socket_id, name) schema = UserSchema() db.session.add(user) db.session.commit() return schema.dump(user) except SQLAlchemyError as e: db.session.rollback() error = str(e.__dict__) return error
def protected(): user_id = get_jwt_identity() user = User.query.get(user_id) user_schema = UserSchema() notebooks = user_schema.dump(user).data['notebooks'] numOfNotes = 0 for notebook in Notebook.query.filter_by(user_id=user.id): numOfNotes += Note.query.filter_by(notebook_id=notebook.id).count() resp = jsonify({'notebooks': notebooks, 'numOfNotes': numOfNotes}) return resp, 200
def read_all(): ''' Retrieves a list of all users from the database. :return: list ''' # get list of users users = User.query.order_by(User.username).all() # convert list to a string user_schema = UserSchema(many=True) data = user_schema.dump(users) return data
def get_all(): """ @route: /api/v1/user @method: GET @return: json string of list of user """ # Create the list of user users = User.query.order_by(User.last_name).all() # Serialize the data for the response user_schema = UserSchema(many=True) data = user_schema.dump(users) return data
def read_all(): """ This function responds to a request for /api/user with the complete lists of users :return: json string of list of users """ # Create the list of people from our data users = User.query.order_by(User.user_name).all() # Serialize the data for the response schema = UserSchema(many=True) data = schema.dump(users).data return data
def read_one_user(userID): user = User.query.filter(User.userID == userID).one_or_none() if user is not None: user_schema = UserSchema() data = user_schema.dump(user).data return data else: abort( 404, "User not found for ID: {userID}".format(userID=userID), )
def create(user): schema = UserSchema() new_user = schema.load(user, session=db.session) new_user.password = User.hash(new_user.password) userDB = User.query \ .filter(User.email == new_user.email) \ .one_or_none() if userDB is not None: return Response(status=409) db.session.add(new_user) db.session.commit() access_token = create_access_token(identity=new_user) refresh_token = create_refresh_token(identity=new_user) return Response(response=schema.dump(new_user), status=201, mimetype='application/json')
def get_by_id(user_id): ''' Retrieves a user for given id if such one exists in the database. :param user_id: int :return: dict ''' # retrieve an existing user user = (User.query.filter( User.user_id == user_id).outerjoin(ContactDetail).one_or_none()) if not user: abort(404, 'Failed to find user with id: {}'.format(user_id)) # convert db object to a string user_schema = UserSchema() data = user_schema.dump(user) return data
def create(user): username = user.get('username') password = user.get('password') salt = user.get('salt') existing_user = User.query.filter(User.username == username).one_or_none() if existing_user is None: schema = UserSchema() new_user = schema.load(user, session = db.session) db.session.add(new_user) db.session.commit() return schema.dump(new_user), 201 else: abort(409, 'User {username} exists already'.format(username=username))
def get_one(user_id): """ @route: /api/v1/user/:id @method: GET @return: user that matches the given id """ # Get the user requested user = User.query.filter(User.id == user_id).one_or_none() # Check if user exists if user is not None: #Serialize the data for the response user_schema = UserSchema() data = user_schema.dump(user) return data else: abort( 404, "Couldn't find any user with ID: {user_id}".format( user_id=user_id))
def read_all(user_ids=None): """ This function responds to a request for /api/people with the complete lists of people :return: json string of list of people """ # Create the list of people from our data if not user_ids: users = User.query.order_by(User.user_id).all() else: users = User.query \ .filter(User.user_id.in_(user_ids)) \ .all() # Serialize the data for the response user_schema = UserSchema(many=True, exclude=["transactions", "pools", "pool"]) data = user_schema.dump(users).data return data