def post(self):
""" Create a new user """
data = request.get_json()
if len(data) == 5:
public_id = str(uuid.uuid4()),
first_name = data['first_name'],
last_name = data['last_name'],
email = data['email'],
username = data['username'],
password = generate_password_hash(data['password']),
is_admin = False
else:
return make_response(
jsonify({'message': 'Required fields count not matched!'}),
401)
try:
if public_id and first_name and last_name and email and username and password:
conn = mysql.connect()
cursor = conn.cursor()
existing_user = cursor.execute(queries.SELECT_BY_USERNAME,
username)
existing_email = cursor.execute(queries.SELECT_BY_EMAIL, email)
conn.commit()
cursor.close()
conn.close()
if existing_user == 1:
return make_response(
jsonify({'message': 'User already exists!'}), 401)
if existing_email == 1:
return make_response(
jsonify({'message': 'Email already exists!'}), 401)
if existing_user == 0 and existing_email == 0:
data = (
public_id,
first_name,
last_name,
email,
username,
password,
is_admin,
)
conn = mysql.connect()
cursor = conn.cursor()
cursor.execute(queries.INSERT_TABLE, data)
conn.commit()
return make_response(
jsonify({'message': 'User created successfully!'}),
200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
return make_response(jsonify({'message': 'Database Exception!'}),
401)
def get(self):
"""Get the list of events"""
public_id = get_jwt_identity()
try:
if public_id:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(user_queries.SELECT_BY_PUBLIC_ID, public_id)
row = cursor.fetchone()
cursor.close()
conn.close()
print(safe_str_cmp(public_id, row['public_id']))
if safe_str_cmp(public_id, row['public_id']):
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(event_queries.SELECT_USER_CREATED_EVENTS,
public_id)
rows = cursor.fetchall()
cursor.close()
conn.close()
events_list = []
for event in rows:
event_data = {}
event_data['public_id'] = event['public_id']
event_data['name'] = event['name']
event_data['category'] = event['category']
event_data['details'] = event['details']
event_data['address'] = event['address']
event_data['county'] = event['county']
event_data['state'] = event['state']
date = event['date']
event_data['date'] = date.strftime("%x")
event_data['time'] = str(event['time'])
event_data['user_public_id'] = event['user_public_id']
event_data['username'] = event['username']
event_data['first_name'] = event['first_name']
event_data['last_name'] = event['last_name']
events_list.append(event_data)
return jsonify({'events': events_list})
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
return make_response(jsonify({'message': 'Database Exception!'}),
401)
return make_response(jsonify({'message': 'Unauthorized request!'}),
401)
def get(self):
try:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(event_queries.SELECT_EVENTS)
rows = cursor.fetchall()
cursor.close()
conn.close()
events_list = []
for event in rows:
event_data = {}
event_data['public_id'] = event['public_id']
event_data['name'] = event['name']
event_data['category'] = event['category']
event_data['details'] = event['details']
event_data['address'] = event['address']
event_data['county'] = event['county']
event_data['state'] = event['state']
date = event['date']
event_data['date'] = date.strftime("%x")
event_data['time'] = str(event['time'])
event_data['user_public_id'] = event['user_public_id']
event_data['username'] = event['username']
event_data['first_name'] = event['first_name']
event_data['last_name'] = event['last_name']
events_list.append(event_data)
return jsonify({'events': events_list})
except Exception as e:
print(e)
return make_response(jsonify({'message': 'Database Exception!'}),
401)
def get(self):
""" Get user details """
public_id = get_jwt_identity()
try:
if public_id:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(queries.SELECT_BY_PUBLIC_ID, public_id)
row = cursor.fetchone()
user_data = {}
user_data['public_id'] = row['public_id']
user_data['first_name'] = row['first_name']
user_data['last_name'] = row['last_name']
user_data['email'] = row['email']
user_data['username'] = row['username']
user_data['admin'] = row['is_admin']
return make_response(jsonify({'user': user_data}), 200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def delete(self):
"""Remove an event"""
user_public_id = get_jwt_identity()
data = request.get_json()
events_public_id = data["events_public_id"]
try:
if user_public_id and events_public_id:
input_data = (
events_public_id,
user_public_id,
)
conn = mysql.connect()
cursor = conn.cursor()
return_code = cursor.execute(event_queries.DELETE_EVENT,
input_data)
conn.commit()
if return_code == 1:
return make_response(
jsonify({'message': 'Event deleted successfully'}),
200)
else:
return make_response(
jsonify({'message': 'Event deletion failed'}), 200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
conn.rollback()
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def get(self):
"""Get the list of user-specific RSVP's"""
public_id = get_jwt_identity()
try:
if public_id:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(rsvp_queries.SELECT_USER_RSVP, public_id)
rows = cursor.fetchall()
print(rows)
cursor.close()
conn.close()
events_list = []
for event in rows:
event_data = {}
event_data['public_id'] = event['public_id']
event_data['name'] = event['name']
event_data['category'] = event['category']
event_data['details'] = event['details']
event_data['address'] = event['address']
event_data['county'] = event['county']
event_data['state'] = event['state']
date = event['date']
event_data['date'] = date.strftime("%x")
event_data['time'] = str(event['time'])
events_list.append(event_data)
return jsonify({'events': events_list})
else:
return make_response(jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
return make_response(jsonify({'message': 'Database Exception!'}), 401)
return make_response(jsonify({'message': 'Unauthorized request!'}), 401)
def put(self):
""" Change Email """
data = request.get_json()
if len(data) == 1:
email = data['email']
public_id = get_jwt_identity()
else:
return make_response(
jsonify({'message': 'Required fields count not matched!'}),
401)
try:
if email and public_id:
data = (
email,
public_id,
)
conn = mysql.connect()
cursor = conn.cursor()
cursor.execute(queries.UPDATE_EMAIL, data)
conn.commit()
return make_response(
jsonify({'message': 'Email changed successfully!'}), 200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
conn.rollback()
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def post(self):
""" Update First Name, Last Name """
data = request.get_json()
if len(data) == 2:
first_name = data['first_name'],
last_name = data['last_name']
public_id = get_jwt_identity()
else:
return make_response(
jsonify({'message': 'Required fields count not matched!'}),
401)
try:
if first_name and last_name and public_id:
data = (
first_name,
last_name,
public_id,
)
conn = mysql.connect()
cursor = conn.cursor()
cursor.execute(queries.UPDATE_NAME, data)
conn.commit()
return make_response(
jsonify({'message': 'Name updated successfully!'}), 200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
conn.rollback()
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def post(self):
""" Update Password """
data = request.get_json()
if len(data) == 1:
password = generate_password_hash(data['password'])
public_id = get_jwt_identity()
else:
return make_response(
jsonify({'message': 'Required fields count not matched!'}),
401)
try:
if password and public_id:
data = (
password,
public_id,
)
conn = mysql.connect()
cursor = conn.cursor()
cursor.execute(queries.UPDATE_PASSWORD, data)
conn.commit()
return make_response(
jsonify({'message': 'Password updated successfully!'}),
200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
conn.rollback()
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def put(self):
""" Insert a user's rsvp """
user_public_id = get_jwt_identity()
data = request.get_json()
if len(data) != 1:
return make_response(jsonify({'message': 'Required fields count not matched!'}), 401)
else:
events_public_id = data['event_public_id']
try:
# check if the row already exists in DB
if user_public_id and events_public_id:
query_data = (user_public_id, events_public_id, )
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(rsvp_queries.CHECK_RECORD, query_data)
row = cursor.fetchone()
conn.commit()
cursor.close()
conn.close()
count = row['record_count']
if count == 1:
return make_response(jsonify({'message': 'User RSVP already exists!'}), 401)
else:
conn = mysql.connect()
cursor = conn.cursor()
insert_status = cursor.execute(
rsvp_queries.INSERT_RSVP, query_data)
conn.commit()
cursor.close()
conn.close()
if insert_status == 0:
return make_response(jsonify({'message': 'RSVP failed!'}), 401)
else:
return make_response(
jsonify(
{'message': 'RSVP was successfully!'}), 200
)
else:
return make_response(jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
return make_response(jsonify({'message': 'Database Exception!'}), 401)
return make_response(jsonify({'message': 'Unauthorized request!'}), 401)
def put(self):
""" Update Event"""
user_public_id = get_jwt_identity()
data = request.get_json()
if len(data) == 9:
public_id = data['public_id']
name = data['name']
category = data['category']
details = data['details']
address = data['address']
county = data['county']
state = data['state']
date = data['date']
time = data['time']
else:
return make_response(
jsonify({'message': 'Required fields count not matched!'}),
401)
try:
if user_public_id and public_id and name and category and details \
and address and county and state and date and time:
data = (
name,
category,
details,
address,
county,
state,
date,
time,
public_id,
user_public_id,
)
conn = mysql.connect()
cursor = conn.cursor()
query_result = cursor.execute(event_queries.UPDATE_EVENT, data)
conn.commit()
if query_result == 1:
return make_response(
jsonify({'message': 'Event updated successfully!'}),
200)
else:
return make_response(
jsonify({'message': 'Event updation failed!'}), 401)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
conn.rollback()
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def get(self):
"""Get the list of users"""
public_id = get_jwt_identity()
try:
if public_id:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(queries.SELECT_BY_PUBLIC_ID, public_id)
row = cursor.fetchone()
cursor.close()
conn.close()
is_admin = row['is_admin']
if is_admin:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cursor.execute(queries.SELECT_ALL)
users = cursor.fetchall()
cursor.close()
conn.close()
output = []
for user in users:
user_data = {}
user_data['public_id'] = user['public_id']
user_data['first_name'] = user['first_name']
user_data['last_name'] = user['last_name']
user_data['email'] = user['email']
user_data['username'] = user['username']
user_data['admin'] = user['is_admin']
output.append(user_data)
return jsonify({'users': output})
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
return make_response(jsonify({'message': 'Database Exception!'}),
401)
return make_response(jsonify({'message': 'Unauthorized request!'}),
401)
def delete(self):
"""Delete user's RSVP for an event"""
user_public_id = get_jwt_identity()
data = request.get_json()
if len(data) != 1:
return make_response(jsonify({'message': 'Required fields count not matched!'}), 401)
else:
try:
event_public_id = data['event_public_id']
if user_public_id and event_public_id:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
query_data = (user_public_id, event_public_id,)
cursor.execute(
rsvp_queries.SELECT_USER_RSVP_BY_EVENT, query_data)
row = cursor.fetchone()
cursor.close()
conn.close()
if row:
conn = mysql.connect()
cursor = conn.cursor()
query_result = cursor.execute(
rsvp_queries.DELETE_RSVP, query_data)
conn.commit()
cursor.close()
conn.close()
if query_result == 1:
return make_response(jsonify({'message': 'RSVP deleted successfully!'}), 200)
else:
return make_response(jsonify({'message': 'RSVP deletion failed!'}), 401)
else:
return make_response(jsonify({'message': 'RSVP for the event not found!'}), 401)
else:
return make_response(jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
print(e)
return make_response(jsonify({'message': 'Database Exception!'}), 401)
return make_response(jsonify({'message': 'Unauthorized request!'}), 401)
def put(self):
""" Escalate user privileges to admin """
public_id = get_jwt_identity()
try:
if public_id:
conn = mysql.connect()
cursor = conn.cursor()
cursor.execute(queries.UPDATE_ADMIN_STATUS, 1)
conn.commit()
return make_response(
jsonify({'message': 'User promoted to Admin!'}), 200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
conn.rollback()
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def delete(self):
""" Remove a user """
public_id = get_jwt_identity()
try:
if public_id:
conn = mysql.connect()
cursor = conn.cursor()
cursor.execute(queries.DELETE_BY_PUBLIC_ID, public_id)
conn.commit()
return make_response(
jsonify({'message': 'User deleted successfully'}), 200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
conn.rollback()
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def post(self):
""" User Login """
json_data = request.get_json()
if len(json_data) == 2:
input_user = json_data['username']
input_password = json_data['password']
else:
return make_response(
jsonify({'message': 'Required fields count not matched!'}),
401)
try:
if input_user and input_password:
conn = mysql.connect()
cursor = conn.cursor(pymysql.cursors.DictCursor)
cur = cursor.execute(queries.SELECT_BY_USERNAME, input_user)
result = cursor.fetchone()
if safe_str_cmp(result['username'], input_user) \
and check_password_hash(result['password'], input_password):
access_token = create_access_token(
identity=result['public_id'], fresh=True)
refresh_token = create_refresh_token(result['public_id'])
return make_response(
jsonify({
'access token': access_token,
'refresh token': refresh_token
}), 200)
else:
return make_response(
jsonify({'message': 'Invalid Credentials!'}), 401)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}), 401)
except Exception as e:
return make_response(jsonify({'message': 'Database Exception!'}),
401)
finally:
cursor.close()
conn.close()
def post(self):
""" Create a new event """
user_public_id = get_jwt_identity()
data = request.get_json()
if len(data) != 8:
return make_response(
jsonify({'message': 'Required fields count not matched!'}),
401)
else:
public_id = str(uuid.uuid4())
name = data['name']
category = data['category']
details = data['details']
address = data['address']
county = data['county']
state = data['state']
date = data['date']
time = data['time']
try:
# check if the row already exists in DB
if public_id and name and category and details and address and \
county and state and date and time and user_public_id:
data = (
public_id,
name,
category,
details,
address,
county,
state,
date,
time,
user_public_id,
)
conn = mysql.connect()
cursor = conn.cursor()
insert_status = cursor.execute(event_queries.INSERT_EVENT,
data)
conn.commit()
cursor.close()
conn.close()
if insert_status == 0:
return make_response(
jsonify({'message': 'Event creation failed!'}),
401)
else:
return make_response(
jsonify({
'message': 'Event was created successfully!',
'public_id': public_id
}), 200)
else:
return make_response(
jsonify({'message': 'Required fields not found!'}),
401)
except Exception as e:
print(e)
return make_response(
jsonify({'message': 'Database Exception!'}), 401)
return make_response(jsonify({'message': 'Unauthorized request!'}),
401)
