def start_handler_any(self, action, trip, user):
users = MongoController.getCollection("online")
active_trips = MongoController.getCollection("active_trips")
if user["type"] == User.USER_TYPE_PASSENGER:
if user["state"] != User.USER_PSG_WAITING_DRIVER:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - passenger is not waiting for driver")
trip_state = TripStates.TRIP_STARTED_PASSENGER
user_state = User.USER_PSG_WAITING_START
theother = list(users.find({ "_id" : trip["driverId"]}))[0]
if user["type"] == User.USER_TYPE_DRIVER:
if user["state"] != User.USER_DRV_GOING_TO_PICKUP:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - driver is not going to pickup")
trip_state = TripStates.TRIP_STARTED_DRIVER
user_state = User.USER_DRV_WAITING_START
theother = list(users.find({ "_id" : trip["passengerId"]}))[0]
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "time_start_waiting" : datetime.datetime.now().isoformat() } } )
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : trip_state } } )
users.update( { "_id" : user["_id"] }, { "$set" : { "state" : user_state } } )
# Send notification to the other user
NotificationSender().notifyUser(theother["username"], user["username"] + " is ready to start the trip!")
trip = list(active_trips.find({"_id" : trip["_id"]}))[0]
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Trip was updated.", action["action"], trip])
def reject_handler(self, action, trip, userId):
if not userId == trip["passengerId"]:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - you are not the passenger of this trip")
users = MongoController.getCollection("online")
passenger = list(users.find({"_id" : userId}))
if len(passenger) > 1:
return ResponseMaker.response_error(constants.ERROR, "Internal server error - more than one user with same ID.")
if len(passenger) == 0:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - user not found")
passenger = passenger[0]
if not trip["state"] == TripStates.TRIP_ACCEPTED:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - wrong trip state")
if not passenger["state"] == User.USER_PSG_SELECTING_DRIVER:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - wrong passenger state")
driver = list(users.find({ "_id" : trip["driverId"]}))[0]
active_trips = MongoController.getCollection("active_trips")
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : TripStates.TRIP_PROPOSED } } )
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "driverId" : -1 } })
users.update( { "_id" : userId }, { "$set" : { "state" : User.USER_PSG_WAITING_ACCEPT } } )
users.update( { "_id" : trip["driverId"] }, { "$set" : { "state" : User.USER_DRV_IDLE } } )
users.update( { "_id" : trip["driverId"] }, { "$set" : { "tripId" : "" } } )
NotificationSender().notifyUser(driver["username"], "Trip rejected")
NotificationSender().notifyUser(passenger["username"], "Driver rejected!")
trip = list(active_trips.find({"_id" : trip["_id"]}))[0]
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Trip was updated.", action["action"], trip])
def payment_handler(self, action, trip, userId):
if not userId == trip["passengerId"]:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - you were not the passenger of this trip")
if not trip["state"] in TripStates.TRIP_ABLE_TO_PAY:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - this trip cannot be payed yet")
shared_trip = { "trip" : TripStates.trip_to_shared(trip), "paymethod" : action["paymethod"] }
try:
(status_code, response) = ServerRequest.createTrip(shared_trip)
except Exception as e:
logger.getLogger().exception(str(e))
print(str(e))
return ResponseMaker.response_error(500, "Internal Error")
logger.getLogger().exception(shared_trip)
if not status_code == constants.CREATE_SUCCESS:
return ResponseMaker.response_object(status_code, ["message", "to_shared"], ["Payment API error, try again", shared_trip])
active_trips = MongoController.getCollection("active_trips")
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : TripStates.TRIP_PAYED } } )
active_trips.remove( { "_id" : trip["_id"] } )
users = MongoController.getCollection("online")
users.update( { "_id" : userId }, { "$set" : { "state" : User.USER_PSG_IDLE} } )
users.update( { "_id" : userId }, { "$set" : { "tripId" : "" } } )
return ResponseMaker.response_object(status_code, ["paymethod"], [response])
def cancel_handler(self, action, trip, userId):
if not userId == trip["passengerId"] and not userId == trip["driverId"]:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - you are not the owner of this trip")
if not trip["state"] in TripStates.TRIP_CANCELABLE:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - this trip cannot be cancelled")
active_trips = MongoController.getCollection("active_trips")
active_trips.remove( { "_id" : trip["_id"] })
users = MongoController.getCollection("online")
users.update( { "_id" : trip["passengerId"] }, { "$set" : { "state" : User.USER_PSG_IDLE, "tripId" : "" } })
if userId != trip["passengerId"]:
passenger = list(users.find({ "_id" : trip["passengerId"]}))[0]
NotificationSender().notifyUser(passenger["username"], "Your trip has been canceled!")
# If trip had a driver, change it's state
if trip["driverId"] >= 0:
users.update( { "_id" : trip["driverId"] }, { "$set" : { "state" : User.USER_DRV_IDLE, "tripId" : "" } })
# Send firebase notification
driver = list(users.find({ "_id" : trip["driverId"]}))[0]
NotificationSender().notifyUser(driver["username"], "Your trip has been canceled!")
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Trip was deleted. Passenger updated.", action["action"], trip])
def finish_handler_any(self, action, trip, user):
users = MongoController.getCollection("online")
active_trips = MongoController.getCollection("active_trips")
if user["type"] == User.USER_TYPE_PASSENGER:
if user["state"] != User.USER_PSG_TRAVELING:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - passenger is not traveling")
trip_state = TripStates.TRIP_FINISHED_PASSENGER
user_state = User.USER_PSG_WAITING_FINISH
theother = list(users.find({ "_id" : trip["driverId"]}))[0]
if user["type"] == User.USER_TYPE_DRIVER:
if user["state"] != User.USER_DRV_TRAVELING:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - driver is not traveling")
trip_state = TripStates.TRIP_FINISHED_DRIVER
user_state = User.USER_DRV_WAITING_FINISH
theother = list(users.find({ "_id" : trip["passengerId"]}))[0]
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : trip_state } } )
users.update( { "_id" : user["_id"] }, { "$set" : { "state" : user_state } } )
NotificationSender().notifyUser(theother["username"], user["username"] + " wants to finish the trip!")
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Trip was updated.", action["action"], trip])
def rate_handler(self, action, trip, userId):
if not userId == trip["passengerId"]:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - you were not the passenger of this trip")
if not trip["state"] == TripStates.TRIP_FINISHED:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - this trip cannot be rated")
if action["rating"] > 5 or action["rating"] < 0:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - thats not a valid rating")
# Retrieve driver
users = MongoController.getCollection("online")
passenger = list(users.find({"_id" : userId}))[0]
driver = list(users.find({"_id" : trip["driverId"]}))[0]
if not passenger["state"] == User.USER_PSG_ARRIVED:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - wrong passenger state")
active_trips = MongoController.getCollection("active_trips")
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : TripStates.TRIP_FINISHED_RATED } } )
rating_count = driver["rating"]["rateCount"] + 1
current_rate = driver["rating"]["rate"] + action["rating"]
logger.getLogger().debug("User [" + str(passenger["_id"]) + "] rated with " + str(action["rating"]) + " driver [" + str(driver["_id"]) + "]")
users.update( { "_id" : driver["_id"] }, { "$set" : { "rating.rateCount" : rating_count } } )
users.update( { "_id" : driver["_id"] }, { "$set" : { "rating.rate" : current_rate } } )
NotificationSender().notifyUser(driver["username"], "You just got a new review!")
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Rating saved.", action["action"], trip])
def post(self):
logger.getLogger().debug("POST at /payment")
# (validate-token) Validate user token
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing token")
users = MongoController.getCollection("online")
active_trips = MongoController.getCollection("active_trips")
payment_info = request.json
trip = list(active_trips.find({"_id" : payment_info["trip"]["_id"]}))
if len(trip) == 0:
return ResponseMaker.response_error(constants.NOT_FOUND, "Error - this trip has no pending payment.")
if payment_info["passengerId"] != trip["passengerId"]:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - you are not the owner of this trip.")
if trip["state"] != TripStates.TRIP_FINISHED:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - this trip has not concluded.")
try:
status_code, response = ServerRequest.makePayment(trip["passengerId"],payment_info)
if status_code == constants.SUCCESS:
transaction = response
active_trips.delete({"_id":trip["_id"]})
users.update({"_id":trip["passengerId"]}, {"$set":{"state":User.USER_PSG_IDLE, "tripId" : "" }})
users.update({"_id":trip["driverId"]}, {"$set":{"state":User.USER_DRV_IDLE, "tripId" : "" }})
NotificationSender.notifyUser(trip["passengerId"], "Your payment was successfully processed. Thank you for choosing FIUBER.")
logger.getLogger().debug("Trip " + str(trip["_id"]) + "successfully paid.")
return ResponseMaker.response_object(constants.SUCCESS, ["transaction"], transaction)
logger.getLogger().error("ERROR ocurred when attempting to pay trip: " + str(trip["_id"]))
return ResponseMaker.response_error(constants.ERROR, "This transaction was unsuccessful. " + str(response["message"]))
except Exception as e:
return ResponseMaker.response_error(constants.ERROR, "Error - an error ocurred during this transaction.")
def post(self):
print(request.json)
logger.getLogger().debug("POST at /users/logout")
logger.getLogger().debug(request.json)
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
result = TokenGenerator.validateToken(token)
# (mongodb) Return all logged in users.
users_online = MongoController.getCollection("online")
user = [
User.UserJSON(user) for user in users_online.find()
if (user['username'] == result[1]['username'])
]
if (len(user) == 0):
return ResponseMaker.response_error(constants.NOT_FOUND,
"User not found")
#users_online.delete_many(user[0]);
users_online.update({"_id": user[0]["_id"]},
{"$set": {
"online": False
}})
return ResponseMaker.response_object(constants.SUCCESS, ['user'],
[user[0]])
def get(self, id):
logger.getLogger().debug("GET at /trips/" + str(id))
# (validate-token) Validate user token
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, response) = TokenGenerator.validateToken(token)
if not valid:
return ResponseMaker.response_error(constants.UNAUTHORIZED,
"Unauthorized")
active_trips = MongoController.getCollection("active_trips")
trip = list(active_trips.find({"_id": id}))
if len(trip) == 0:
return ResponseMaker.response_error(constants.NOT_FOUND,
"Not found")
# This should never happen
if len(trip) > 1:
return ResponseMaker.response_error(
constants.ERROR,
"Internal server error - more than one trip with same ID")
trip = trip[0]
print(trip)
return ResponseMaker.response_object(constants.SUCCESS,
["message", "trip"], ["OK", trip])
def finish_handler(self, action, trip, userId):
if not userId == trip["passengerId"] and not userId == trip["driverId"]:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - you are not part of this trip")
if trip["state"] not in TripStates.TRIP_FINISH_VALID:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - trip is not started")
# Retrieve user
users = MongoController.getCollection("online")
user = list(users.find({"_id" : userId}))
if len(user) > 1:
return ResponseMaker.response_error(constants.ERROR, "Internal server error - more than one user with same ID.")
if len(user) == 0:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - user not found")
user = user [0]
# Anyone can finish first
if trip["state"] == TripStates.TRIP_STARTED:
return self.finish_handler_any(action, trip, user)
elif trip["state"] == TripStates.TRIP_FINISHED_DRIVER:
return self.finish_handler_passenger(action, trip, user)
elif trip["state"] == TripStates.TRIP_FINISHED_PASSENGER:
return self.finish_handler_driver(action, trip, user)
return ResponseMaker.response_error(constants.PARAMERR, "Internal server error.")
def finish_handler_driver(self, action, trip, user):
users = MongoController.getCollection("online")
active_trips = MongoController.getCollection("active_trips")
if user["state"] != User.USER_DRV_TRAVELING:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - driver is not traveling")
passenger = list(users.find({ "_id" : trip["passengerId"]}))[0]
if passenger["state"] != User.USER_PSG_WAITING_FINISH:
return ResponseMaker.response_error(constants.ERROR, "Internal server error - passenger in a bad state")
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : TripStates.TRIP_FINISHED } } )
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "time_finish" : datetime.datetime.now().isoformat() } } )
users.update( { "_id" : user["_id"]}, { "$set" : { "state" : User.USER_DRV_IDLE } } )
users.update( { "_id" : user["_id"]}, { "$set" : { "tripId" : "" } } )
users.update( { "_id" : passenger["_id"] }, { "$set" : { "state" : User.USER_PSG_ARRIVED } } )
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Trip just started.", action["action"], trip])
def start_handler(self, action, trip, userId):
if not userId == trip["passengerId"] and not userId == trip["driverId"]:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden - you are not the owner of this trip")
if trip["state"] not in TripStates.TRIP_START_VALID:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - this trip cannot start")
# Retrieve user
users = MongoController.getCollection("online")
user = list(users.find({"_id" : userId}))
if len(user) > 1:
return ResponseMaker.response_error(constants.ERROR, "Internal server error - more than one user with same ID.")
if len(user) == 0:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - user not found")
user = user[0]
#dist = Distances.computeDistance(user["coord"], trip["directions"]["origin"])
#logger.getLogger().debug("Distance from user [" + user["username"] + "] to starting point is " + str(dist))
#if dist > MAXIMUM_USER_DISTANCE:
# return ResponseMaker.response_error(constants.PARAMERR, "Bad request - you are too far away from the starting point")
# Anyone can accept first
if trip["state"] == TripStates.TRIP_CONFIRMED:
return self.start_handler_any(action, trip, user)
elif trip["state"] == TripStates.TRIP_STARTED_DRIVER:
return self.start_handler_passenger(action, trip, user)
elif trip["state"] == TripStates.TRIP_STARTED_PASSENGER:
return self.start_handler_driver(action, trip, user)
return ResponseMaker.response_error(constants.PARAMERR, "Internal server error.")
def userId_is_passenger(self, id):
users_online = MongoController.getCollection("online")
for user in users_online.find():
if user["_id"] == id:
found = user
return (user, user["type"] == "passenger")
return (None, False)
def start_handler_driver(self, action, trip, user):
users = MongoController.getCollection("online")
active_trips = MongoController.getCollection("active_trips")
if user["state"] != User.USER_DRV_GOING_TO_PICKUP:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - driver is not going to pickup")
passenger = list(users.find({ "_id" : trip["passengerId"]}))[0]
if passenger["state"] != User.USER_PSG_WAITING_START:
return ResponseMaker.response_error(constants.ERROR, "Internal server error - passenger in a bad state")
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : TripStates.TRIP_STARTED } } )
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "time_start" : datetime.datetime.now().isoformat() } } )
users.update( { "_id" : user["_id"]}, { "$set" : { "state" : User.USER_DRV_TRAVELING} } )
users.update( { "_id" : passenger["_id"] }, { "$set" : { "state" : User.USER_PSG_TRAVELING} } )
trip = list(active_trips.find({"_id" : trip["_id"]}))[0]
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Trip just started.", action["action"], trip])
def accept_handler(self, action, trip, userId):
if not trip["state"] == TripStates.TRIP_PROPOSED:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - trip is not in valid state to accept.")
users = MongoController.getCollection("online")
user = list(users.find({"_id" : userId}))
if len(user) > 1:
return ResponseMaker.response_error(constants.ERROR, "Internal server error - more than one user with same ID.")
if len(user) == 0:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - user not found")
user = user[0]
if not user["type"] == User.USER_TYPE_DRIVER:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - user is not driver")
# The user is a passenger
if not user["state"] == User.USER_DRV_IDLE:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - driver is busy")
### The action itself:
# 1) Update the trip to TRIP_ACCEPTED
# 1bis) Update trip driver info to userId
# 2) Update driver status to USER_DRV_WAITING_CONFIRMATION
# 3) Update passenger status to USER_PSG_SELECTING_DRIVER
# 4) Send firebase notification to passenger
active_trips = MongoController.getCollection("active_trips")
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "state" : TripStates.TRIP_ACCEPTED } })
active_trips.update( { "_id" : trip["_id"] }, { "$set" : { "driverId" : userId } })
users.update( { "_id" : userId }, { "$set" : { "state" : User.USER_DRV_WAITING_CONFIRMATION, "tripId" : trip["_id"] } } )
users.update( { "_id" : trip["passengerId"] }, { "$set" : { "state" : User.USER_PSG_SELECTING_DRIVER } } )
trip = list(active_trips.find( { "_id" : trip["_id"] }))[0]
passenger = list(users.find({ "_id" : trip["passengerId"]}))[0]
NotificationSender().notifyUser(passenger["username"], "Trip accepted")
trip = list(active_trips.find({"_id" : trip["_id"]}))[0]
print(trip)
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action", "trip"], ["Trip was accepted. Driver updated.", action["action"], trip])
def get(self):
logger.getLogger().debug("GET at /trips")
# (validate-token) Validate user token
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, requester) = TokenGenerator.validateToken(token)
if not valid:
return ResponseMaker.response_error(constants.UNAUTHORIZED,
"Unauthorized")
# Check if user is 1) logged in, and 2) a passenger
(user, is_passenger) = self.userId_is_passenger(requester["_id"])
if user == None:
return ResponseMaker.response_error(
constants.PARAMERR, "Bad request - user is not logged in")
if is_passenger:
return ResponseMaker.response_error(
constants.FORBIDDEN, "Forbidden - user is not driver")
logger.getLogger().debug("The 'driver' requesting trips is: " +
str(user["_id"]) + "-" + user["username"])
## Actual getting of the trips!
params = request.args
active_trips = MongoController.getCollection("active_trips")
trips = list(active_trips.find())
if "filter" in params:
trips = [
trip for trip in trips if trip["state"] == params["filter"]
]
if "sort" in params and params["sort"] == "near":
trips.sort(key=lambda x: Distances.computeDistance(
user["coord"], x["directions"]["origin"]))
if "limit" in params:
limit = int(params["limit"])
if limit > 0:
trips = trips[:(limit)]
return ResponseMaker.response_object(constants.SUCCESS,
["message", "trips"],
["Getting trips!", trips])
def post(self):
print(request.json)
logger.getLogger().debug("POST at /users")
logger.getLogger().debug(request.json)
# (shared-server) Send new user data to shared server.
(status, response) = ServerRequest.createUser(request.json)
if (status != constants.CREATE_SUCCESS):
return ResponseMaker.response_error(status, response['message'])
user_js = User.UserJSON(response)
users_online = MongoController.getCollection("online")
users_online.insert_one(user_js)
return ResponseMaker.response_object(status, ['user'], [user_js])
def post(self):
logger.getLogger().debug("POST at /users/login")
logger.getLogger().debug(request.json)
try:
# (shared-server) First ask shared server for credentials validation
(valid, response) = ServerRequest.validateUser(request.json)
if not valid:
logger.getLogger().debug(
'Error 418: I\' m a teapot and your credentials are not valid!'
)
return ResponseMaker.response_error(response.status_code,
"Shared server error")
logger.getLogger().debug(
"Credentials are valid, server responsed with user")
user_js = User.UserJSON(response)
# (token-generation) Generate a new UserToken for that user
token = TokenGenerator.generateToken(response)
users_online = MongoController.getCollection("online")
# (mongodb) If credentials are valid, and user is not here, add it
for user in users_online.find():
if user_js["_id"] == user["_id"]:
# Found it! Checking refs!
logger.getLogger().debug(
"User trying to log in already found in the local db")
if user_js["_ref"] != user["_ref"]:
logger.getLogger().debug(
"Login of an user already in bdd. _ref is old")
user_js = User.UserUpdateDedicatedFields(user_js, user)
else:
user_js = user
break
user_js["online"] = True
users_online.update({"_id": user_js["_id"]}, user_js, upsert=True)
return ResponseMaker.response_object(constants.SUCCESS,
['user', 'token'],
[user_js, token])
except Exception as e:
logger.getLogger().exception(str(e))
print(str(e))
return ResponseMaker.response_error(500, "Internal Error")
def updateDriverLocation(tripId, user):
active_trips = MongoController.getCollection("active_trips")
trip = list(active_trips.find({"_id": tripId}))
if len(trip) <= 0:
return
trip = trip[0]
if not trip["state"] == TRIP_STARTED:
return
if not trip["driverId"] == user["_id"]:
return
logger.getLogger().debug("Pushing new coordinates to trip (id: " +
trip["_id"] + ")")
# Now we know the trip is started, and we are the driver
location = {"lat": user["coord"]["lat"], "lng": user["coord"]["lng"]}
location["timestamp"] = datetime.datetime.now().isoformat()
active_trips.update({"_id": tripId}, {"$push": {"real_route": location}})
def get(self):
logger.getLogger().debug("GET at /users")
# (validate-token) Validate user token
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, response) = TokenGenerator.validateToken(token)
if not valid:
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
# (mongodb) Return all logged in users.
users_online = MongoController.getCollection("online")
aux = [User.UserJSON(user) for user in users_online.find()]
user = list(users_online.find({"_id": response["_id"]}))
if len(user) == 0:
return ResponseMaker.response_error(
constants.PARAMERR, "Bad request - you may not be loged in")
user = user[0]
## Aditional params (only supporting "sort")
params = request.args
if "filter" in params:
aux = [u for u in aux if u["type"] == params["filter"]]
if "sort" in params and params["sort"] == "near":
aux.sort(key=lambda x: Distances.computeDistance(
user["coord"], x["coord"]))
if "limit" in params:
limit = int(params["limit"])
if limit > 0:
aux = aux[:(limit)]
return ResponseMaker.response_object(constants.SUCCESS, ['users'],
[aux])
def __init__(self):
self.users = MongoController.getCollection("online")
def post(self):
print(request.json)
logger.getLogger().debug("POST at /trips")
logger.getLogger().debug(request.json)
# (validate-token) Validate user token
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, requester) = TokenGenerator.validateToken(token)
if not valid:
return ResponseMaker.response_error(constants.UNAUTHORIZED,
"Unauthorized")
# Check if user is 1) logged in, and 2) a passenger
(user, is_passenger) = self.userId_is_passenger(requester["_id"])
if user == None:
return ResponseMaker.response_error(
constants.PARAMERR, "Bad request - user is not logged in")
if not is_passenger:
return ResponseMaker.response_error(
constants.FORBIDDEN, "Forbidden - user is not passenger")
logger.getLogger().debug("The 'passenger' requesting the trip is: " +
str(user["_id"]) + "-" + user["username"])
if not user["state"] == User.USER_PSG_IDLE:
return ResponseMaker.response_error(
constants.PARAMERR, "Bad request - user is not in idle state!")
# Check the trip data is valid!
trip = request.json
if trip == None:
return ResponseMaker.response_errPSG_or(
constants.PARAMERR, "Bad request - missing trip data")
if not self.check_new_trip(trip):
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - bad trip data")
# Creating a new trip
new_trip = {}
new_trip["directions"] = trip
new_trip["passengerId"] = requester["_id"]
new_trip["driverId"] = -1
new_trip["state"] = TripStates.TRIP_PROPOSED
new_trip["_id"] = str(uuid.uuid1())
logger.getLogger().debug("Created trip with uudi: " + new_trip["_id"])
# (shared) Ask shared for a trip cost estimation
(status, response) = ServerRequest.estimateTrip(
TripStates.trip_to_shared(new_trip))
try:
(status, response) = ServerRequest.estimateTrip(
TripStates.trip_to_shared(new_trip))
except Exception as e:
logger.getLogger().exception("No cost estimation from server: " +
str(e))
return ResponseMaker.response_error(
constants.ERROR,
"Internal server error - there is no estimation")
if not status == constants.SUCCESS:
logger.getLogger().exception("No cost estimation from server: " +
str(e))
else:
new_trip["cost"] = response["cost"]
# (mongodb) Storing new trip in the db!
active_trips = MongoController.getCollection("active_trips")
active_trips.insert_one(new_trip)
users = MongoController.getCollection("online")
users.update_one({"_id": user["_id"]}, {
"$set": {
"state": User.USER_PSG_WAITING_ACCEPT,
"tripId": new_trip["_id"]
}
})
return ResponseMaker.response_object(constants.SUCCESS,
["message", "trip"],
["Trip created!", new_trip])
def post(self, id):
logger.getLogger().debug("GET at /trips/" + str(id))
# (validate-token) Validate user token
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing token")
token = request.headers['UserToken']
(valid, user) = TokenGenerator.validateToken(token)
if not valid:
return ResponseMaker.response_error(constants.UNAUTHORIZED, "Unauthorized")
active_trips = MongoController.getCollection("active_trips")
trip = list(active_trips.find({"_id" : id}))
if len(trip) == 0:
return ResponseMaker.response_error(constants.NOT_FOUND, "Not found")
# This should never happen
if len(trip) > 1:
return ResponseMaker.response_error(constants.ERROR, "Internal server error - more than one trip with same ID")
trip = trip[0]
#print(trip)
action = request.json
users = MongoController.getCollection("online")
if action == None:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing action")
if not "action" in action:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing action")
if action["action"] == TripStates.ACTION_CANCEL:
print("Someone wants to delete trip " + trip["_id"])
return self.cancel_handler(action, trip, user["_id"])
if action["action"] == TripStates.ACTION_DRIVER_ACCEPT:
print("Someone wants to accept the trip " + trip["_id"])
return self.accept_handler(action, trip, user["_id"])
if action["action"] == TripStates.ACTION_PASSENGER_CONFIRM:
print("Passenger wants to confirm the driver " + trip["_id"])
return self.confirm_handler(action, trip, user["_id"])
if action["action"] == TripStates.ACTION_PASSENGER_REJECT:
print("Passenger wants to reject the driver " + trip["_id"])
return self.reject_handler(action, trip, user["_id"])
if action["action"] == TripStates.ACTION_START:
print("Someone wants to start the trip " + trip["_id"])
return self.start_handler(action, trip, user["_id"])
if action["action"] == TripStates.ACTION_FINISH:
print("Someone wants to finish the trip" + trip["_id"])
return self.finish_handler(action, trip, user["_id"])
if action["action"] == TripStates.ACTION_RATE:
print("Passenger wants to rate the driver " + trip["_id"])
if not "rating" in action:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - rating action without rating")
return self.rate_handler(action, trip, user["_id"])
if action["action"] == TripStates.ACTION_PAY:
print("Passenger wants to pay " + trip["_id"])
if not "paymethod" in action:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing payment info")
return self.payment_handler(action, trip, user["_id"])
return ResponseMaker.response_object(constants.SUCCESS, ["message", "action"], ["No action performed. Invalid action.", action["action"]])
