def post(self, user_id):
"""Adds a new ride"""
kwargs = self.reqparse.parse_args()
driver_id = str(user_id)
db_cursor = db.con()
db_cursor.execute(
"SELECT * FROM rides WHERE driver_id=%s and departuretime=%s and status=%s",
(
driver_id,
kwargs.get("departuretime"),
"pending",
))
ride = db_cursor.fetchone()
if ride != None:
return make_response(
jsonify(
{"message": "you will be on another ride at that time"}),
400)
ride = kwargs.get("departurepoint") + " to " + kwargs.get(
"destination")
result = models.Ride.create_ride(
ride=ride,
driver_id=driver_id,
departuretime=kwargs.get("departuretime"),
numberplate=kwargs.get("numberplate"),
maximum=str(kwargs.get("maximum")))
return result
def post(self):
"""login a user"""
try:
kwargs = self.reqparse.parse_args()
db_cursor = db.con()
db_cursor.execute("SELECT * FROM users WHERE email=%s",
(kwargs.get("email"), ))
user = db_cursor.fetchone()
if check_password_hash(user[3], kwargs.get("password")) == True:
token = jwt.encode(
{
'id':
user[0],
'admin':
user[4],
'exp':
datetime.datetime.utcnow() +
datetime.timedelta(weeks=3)
}, config.Config.SECRET_KEY)
return make_response(
jsonify({
"message": "successfully logged in",
"token": token.decode('UTF-8')
}), 200)
return make_response(
jsonify({"message": "invalid email address or password"}), 400)
except:
return make_response(
jsonify({"message": "invalid email address or password"}), 400)
def post(self):
"""Register a new user"""
kwargs = self.reqparse.parse_args()
if kwargs.get('password') == kwargs.get('confirm_password'):
if len(kwargs.get('password')) >= 8:
db_cursor = db.con()
db_cursor.execute("SELECT * FROM users WHERE email=%s",
(kwargs.get('email'), ))
user = db_cursor.fetchall()
if user != []:
return make_response(
jsonify(
{"message":
"user with that email already exists"}), 400)
result = models.User(username=kwargs.get('username'),
email=kwargs.get('email'),
password=kwargs.get('password'),
admin=False)
return make_response(
jsonify({"message": "user has been successfully created"}),
201)
return make_response(
jsonify({"message":
"password should be atleast 8 characters"}), 400)
return make_response(
jsonify({
"message":
"password and cofirm password should be identical"
}), 400)
def request_ride(cls, ride_id, user_id, accepted=False, status="pending"):
"""Creates a new request"""
db_cursor = db.con()
db_cursor.execute("SELECT status FROM rides WHERE ride_id=%s", (ride_id,))
ride = db_cursor.fetchone()
if ride[0] == "pending":
cls(ride_id, user_id, accepted, status)
return make_response(jsonify({"message" : "request has been successfully sent for approval"}), 201)
return make_response(jsonify({"message" : "ride is already given"}), 400)
def delete_user(user_id):
"""Deletes a user"""
try:
db_cursor = db.con()
db_cursor.execute("DELETE FROM users WHERE user_id=%s", (user_id,))
db.commit()
return make_response(jsonify({"message" : "user has been successfully deleted"}), 200)
except:
return make_response(jsonify({"message" : "user does not exists"}), 404)
def accept_request(request_id):
"""Accepts request"""
try:
db_cursor = db.con()
db_cursor.execute("UPDATE request SET accepted=%s WHERE request_id=%s", (True, request_id))
db.commit()
return make_response(jsonify({"message" : "request has been successfully accepted"}), 200)
except KeyError:
return make_response(jsonify({"message" : "the specified request does not exist in requests"}), 404)
def __init__(self, ride_id, user_id, accepted, status):
self.ride_id = str(ride_id)
self.user_id = str(user_id)
self.accepted = accepted
self.status = status
new_request = "INSERT INTO request (ride_id, user_id, accepted, status) VALUES " \
"('" + self.ride_id + "', '" + self.user_id + "', '" + '0' + "', '" + self.status + "')"
db_cursor = db.con()
db_cursor.execute(new_request)
db.commit()
def update_user(user_id, username, email, password, admin):
"""Updates user information"""
try:
db_cursor = db.con()
db_cursor.execute("UPDATE users SET username=%s, email=%s, password=%s, admin=%s WHERE user_id=%s",
(username, email, password, admin, user_id))
db.commit()
return make_response(jsonify({"message" : "user has been successfully updated"}), 200)
except:
return make_response(jsonify({"message" : "user does not exist"}), 404)
def delete(self, user_id):
"""Delete a particular user"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM users WHERE user_id=%s", (user_id, ))
user = db_cursor.fetchall()
if user == []:
return make_response(jsonify({"message": "user does not exist"}),
404)
return models.User.delete_user(user_id=user_id)
def get_maximum(request_id):
"""Gets all request"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM request WHERE request_id=%s", (str(request_id),))
request = db_cursor.fetchone()
db_cursor.execute("SELECT maximum FROM rides WHERE ride_id=%s", (request[2],))
maximum = db_cursor.fetchone()
maximum = maximum[0]
return maximum
def update_ride(ride_id, ride, driver_id, departuretime, numberplate,
maximum):
"""Updates ride information"""
try:
db_cursor = db.con()
db_cursor.execute("UPDATE rides SET ride=%s, driver_id=%s, departuretime=%s, numberplate=%s, maximum=%s WHERE ride_id=%s",
(ride, driver_id, departuretime, numberplate, maximum, ride_id))
db.commit()
return make_response(jsonify({"message" : "user has been successfully updated"}), 200)
except:
return make_response(jsonify({"message" : "user does not exist"}), 404)
def put(self, request_id, user_id):
"""accept/reject a particular request"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM request WHERE request_id=%s",
(request_id, ))
requesti = db_cursor.fetchall()
if requesti == []:
return make_response(
jsonify({"message": "request does not exist"}), 404)
driver_id = models.Relation.get_driver_id(request_id)
if type(driver_id) == int and driver_id == int(user_id):
requesti = requesti[0]
ride_id = requesti[2]
if requesti[4] == True:
db_cursor = db.con()
db_cursor.execute(
"UPDATE request SET accepted=%s WHERE request_id=%s",
(False, request_id))
db.commit()
return make_response(
jsonify({"message": "request has been rejected"}), 200)
db_cursor.execute(
"SELECT * FROM request WHERE ride_id=%s and accepted=%s", (
ride_id,
True,
))
accepted = db_cursor.fetchall()
total = len(accepted)
maximum = models.Relation.get_maximum(request_id)
if int(total) < int(maximum):
update = models.Request.accept_request(request_id)
return update
return make_response(
jsonify({"message": "maximum requests have been accepted"}),
400)
return make_response(
jsonify({"message": "the request is not of your ride"}), 400)
def delete_request(request_id):
"""Deletes a request"""
try:
db_cursor = db.con()
db_cursor.execute("DELETE FROM request WHERE request_id=%s", (request_id,))
db.commit()
return make_response(jsonify({"message" : "ride has been successfully deleted"}), 200)
except:
return make_response(jsonify({"message" : "the specified request does not exist in requests"}), 404)
def __init__(self, ride, driver_id, departuretime, numberplate, maximum, status):
self.ride = ride
self.driver_id = driver_id
self.departuretime = departuretime
self.numberplate = numberplate
self.maximum = maximum
self.status = status
new_ride = "INSERT INTO rides (ride, driver_id, departuretime, numberplate, maximum, status) VALUES " \
"('" + self.ride + "', '" + self.driver_id + "', '" + self.departuretime + "', '" + self.numberplate + "','" + self.maximum + "','" + self.status + "' )"
db_cursor = db.con()
db_cursor.execute(new_ride)
db.commit()
def delete_ride(ride_id):
"""Deletes a ride"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM rides")
rides = db_cursor.fetchall()
for ride in rides:
if ride[0] == ride_id:
db_cursor.execute("DELETE FROM rides WHERE ride_id=%s", (ride_id,))
db.commit()
return make_response(jsonify({"message" : "ride has been successfully deleted"}), 200)
return make_response(jsonify({"message" : "user does not exists"}), 404)
def get_requests(request_id):
"""Gets a particular request"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM request WHERE request_id=%s", (request_id,))
request = db_cursor.fetchone()
if request != None:
info = {request[0] : {"user_id": request[1],
"ride_id": request[2],
"status": request[3],
"accepted": request[4]}}
return make_response(jsonify({"request" : info}), 200)
return make_response(jsonify({"message" : "request does not exists"}), 404)
def get_user(user_id):
"""Gets a particular user"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM users WHERE user_id=%s", (user_id,))
user = db_cursor.fetchall()
if user != []:
user=user[0]
info = {user[0] : {"email": user[1],
"username": user[2],
"admin": user[4]}}
return make_response(jsonify({"profile" : info}), 200)
return make_response(jsonify({"message" : "user does not exists"}), 404)
def get_all_users():
"""Gets all users"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM users")
users = db_cursor.fetchall()
all_users = []
for user in users:
info = {user[0] : {"email": user[1],
"username": user[2],
"admin": user[4]}}
all_users.append(info)
return make_response(jsonify({"All users" : all_users}), 200)
def __init__(self, username, email, password, admin):
self.username = username
self.email = email
self.password = generate_password_hash(password, method='sha256')
if admin == True:
self.admin = '1'
else:
self.admin = '0'
new_user = "******" \
"('" + self.username + "', '" + self.email + "', '" + self.password + "', '" + self.admin + "')"
db_cursor = db.con()
db_cursor.execute(new_user)
db.commit()
def get_driver_id(request_id):
"""Gets all request"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM request WHERE request_id=%s", (request_id,))
request = db_cursor.fetchone()
ride_id = str(request[2])
db_cursor.execute("SELECT driver_id FROM rides WHERE ride_id=%s", (ride_id,))
driver_id = db_cursor.fetchone()
if driver_id == None:
return make_response(jsonify({"message" : "ride does not exists"}), 404)
driver_id = driver_id[0]
return int(driver_id)
def get_all_requests():
"""Gets all request"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM request")
requests = db_cursor.fetchall()
ride_requests = []
for request in requests:
info = {request[0] : {"user_id": request[1],
"ride_id": request[2],
"status": request[3],
"accepted": request[4]}}
ride_requests.append(info)
return make_response(jsonify({"ride_requests" : ride_requests}), 200)
def get_particular_riderequests(ride_id):
db_cursor = db.con()
db_cursor.execute("SELECT * FROM request WHERE ride_id=%s", (ride_id,))
requests = db_cursor.fetchall()
if requests != []:
ride_requests = []
for request in requests:
info = {request[0] : {"user_id": request[1],
"ride_id": request[2],
"status": request[3],
"accepted": request[4]}}
ride_requests.append(info)
return make_response(jsonify({"ride_requests" : ride_requests}), 200)
return make_response(jsonify({"message" : "ride does not exists"}), 404)
def get_all_rides():
"""Gets all rides"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM rides")
rides = db_cursor.fetchall()
all_rides = []
for ride in rides:
info = {ride[0] : {"ride": ride[1],
"driver_id": ride[2],
"departure_time": ride[3],
"cost": ride[4],
"maximum": ride[5],
"status": ride[6]}}
all_rides.append(info)
return make_response(jsonify({"All rides" : all_rides}), 200)
def get_ride(ride_id):
"""Gets a particular ride"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM rides WHERE ride_id=%s", (ride_id,))
ride = db_cursor.fetchall()
if ride != []:
ride=ride[0]
info = {ride[0] : {"ride": ride[1],
"driver_id": ride[2],
"departure_time": ride[3],
"cost": ride[4],
"maximum": ride[5],
"status": ride[6]}}
return make_response(jsonify({"ride" : info}), 200)
return make_response(jsonify({"message" : "ride does not exists"}), 404)
def delete(self, request_id, user_id):
"""Delete a particular request"""
currentuser_id = user_id
db_cursor = db.con()
db_cursor.execute("SELECT * FROM request WHERE request_id=%s",
(request_id, ))
request = db_cursor.fetchone()
if request != None:
if currentuser_id == request[1]:
delete = models.Request.delete_request(request_id)
return delete
return make_response(
jsonify({"message": "the request is not yours"}), 400)
return make_response(jsonify({"message": "request does not exists"}),
404)
def start_ride(ride_id, driver_id):
"""starts a ride"""
db_cursor = db.con()
db_cursor.execute("SELECT * FROM rides WHERE ride_id=%s", (ride_id,))
ride = db_cursor.fetchall()
if ride != []:
ride = ride[0]
if int(ride[2]) == driver_id:
db_cursor.execute("UPDATE rides SET status=%s WHERE ride_id=%s", ("given", ride_id,))
db_cursor.execute("UPDATE request SET status=%s WHERE ride_id=%s and accepted=%s", ("taken", ride_id, True,))
db_cursor.execute("UPDATE request SET status=%s WHERE ride_id=%s and accepted=%s", ("rejected", ride_id, False,))
db.commit()
return {"message" : "ride has started"}
return {"message" : "The ride you want to start is not your ride."}
return {"message" : "ride does not exist"}
def put(self, user_id):
"""Update a particular user"""
kwargs = self.reqparse.parse_args()
if kwargs.get('password') == kwargs.get('confirm_password'):
if len(kwargs.get('password')) >= 8:
db_cursor = db.con()
db_cursor.execute("SELECT * FROM users WHERE email=%s",
(kwargs.get('email'), ))
user = db_cursor.fetchall()
if user != []:
return make_response(
jsonify(
{"message":
"user with that email already exists"}), 400)
db_cursor.execute("SELECT * FROM users WHERE user_id=%s",
(user_id, ))
by_id = db_cursor.fetchall()
if by_id == []:
return make_response(
jsonify({"message": "user does not exist"}), 404)
result = models.User.update_user(
user_id=user_id,
username=kwargs.get('username'),
email=kwargs.get('email'),
password=kwargs.get('password'),
admin=kwargs.get('admin'))
return result
return make_response(
jsonify(
{"message": "password should be at least 8 characters"}),
400)
return make_response(
jsonify({
"message":
"password and confirm password should be identical"
}), 400)
def put(self, ride_id, user_id):
"""Update a particular ride"""
kwargs = self.reqparse.parse_args()
driver_id = user_id
db_cursor = db.con()
db_cursor.execute("SELECT * FROM rides WHERE ride_id=%s", (ride_id, ))
ride = db_cursor.fetchall()
if ride == []:
return make_response(jsonify({"message": "ride does not exist"}),
404)
ride = kwargs.get("departurepoint") + " to " + kwargs.get(
"destination")
result = models.Ride.update_ride(
ride_id=ride_id,
ride=ride,
driver_id=driver_id,
departuretime=kwargs.get("departuretime"),
numberplate=kwargs.get("numberplate"),
maximum=kwargs.get("maximum"))
return result
