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 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 post(self):
# register user endpoint
data = validate_user(request.get_json())
if data['ok']:
data = data['data']
# check if user exists
user = User.query.filter_by(email=data['email']).first()
if user:
return { "message" : "Email has already been taken"}, 400
# get password
data['password'] = flask_bcrypt.generate_password_hash(data['password'])
# find the role of the user
role = Role.query.filter_by(name=data['role']).first()
del data['role']
# Add a new patient to db
user_schema = UserSchema()
new_user = user_schema.load(data, session=db.session)
role.users.append(new_user) # add new user to their role
db.session.add(role) # add user and role
db.session.commit()
return {}, 200
else:
return {'message': 'Please check the fields'}, 400
def cant_play_on_saturdays():
email = request.json['email']
weeks = int(request.json['weeks'])
future = bool(request.json['future'])
if weeks <= 0 or weeks > 520:
abort(400)
user = User.query.get(email)
if not user:
abort(404)
if user.group is not current_user.group:
abort(404)
if user.email is not email and not current_user.isGroupOwner:
abort(401)
if future:
user.futureSaturdayAbsentWeeks = weeks
else:
user.isSaturdayAbsent = True
user.saturdayAbsentWeeks = weeks
db.session.commit()
""""Insert a log"""
description = 'Successfully registered Saturday absence for - ' + str(weeks) + ' weeks' + \
' for user - ' + user.firstname + ' ' + user.lastname
log = Log(current_user.email, description)
db.session.add(log)
db.session.commit()
schema = UserSchema()
json_result = schema.dumps(user)
return json_result.data
def want_to_play_on_sundays(email):
user = User.query.get(email)
if not user:
abort(404)
if user.group is not current_user.group:
abort(404)
if user.email is not email and not current_user.isGroupOwner:
abort(401)
user.isSundayAbsent = False
user.sundayAbsentWeeks = 0
user.futureSundayAbsentWeeks = 0
db.session.commit()
""""Insert a log"""
description = 'Successfully registered wantToPlayOnSundays for user - ' + user.firstname + ' ' + user.lastname
log = Log(current_user.email, description)
db.session.add(log)
db.session.commit()
schema = UserSchema()
json_result = schema.dumps(user)
return json_result.data
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 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 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 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 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 add_users():
if request.method == "POST":
username = request.json['username']
if Users.query.filter_by(username=username).first():
return make_response({"err": "user already exist"}, 400)
new_user = Users()
new_user.email = request.json["email"]
new_user.username = request.json["username"]
new_user.fname = request.json["fname"]
new_user.lname = request.json["lname"]
new_user.role = request.json["role"]
db.session.add(new_user)
db.session.commit()
token = ''.join(
random.choices(string.ascii_uppercase + string.digits, k=20))
user_authentication = UserAuthentication()
user_authentication.username = username
user_authentication.token = token
db.session.add(user_authentication)
db.session.commit()
return make_response(
{
"user": UserSchema().dump(new_user),
"token": token
}, 200)
all_users = Users.query.all()
return make_response({"user": UserSchema(many=True).dump(all_users)}, 200)
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 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 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 __init__(self):
super(UserResource, self).__init__()
self.user_schema = UserSchema()
self.users_schema = UserSchema(many=True)
self.per_page = 20 # TODO: move fix num to config file
self.fields = [('username', True), ('password', True), ('email', True),
('role', True)]
self.token_data = ['username', 'password']
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(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 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_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 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 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 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_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 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 user_profile():
user = request.user
issued_books = BookIssue.query.filter_by(uid=user.id)
return make_response(
{
"user": UserSchema().dump(user),
"issued books": BookIssueSchema(many=True).dump(issued_books)
}, 200)
