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