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 /users/userId/cars " + str(id))
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
print(decoded)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
cars = [
user for user in self.users.find()
if user['_id'] == id and user['type'] == 'driver'
]
try:
if (len(cars) == 0):
print("FETECHING CARS...")
status_code, cars = ServerRequest.getUserCars(id)
except Exception as e:
return ResponseMaker.response_error(
constants.NOT_FOUND,
"User id did not match any existing users.")
return ResponseMaker.response_object(constants.SUCCESS, ['cars'], cars)
def delete(self, id):
print("DELETE at /users/id")
logger.getLogger().debug("DELETE at /users/" + str(id))
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
print(decoded)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
#Ask Shared-Server to delete this user
delete_success, status_code = ServerRequest.deleteUser(id)
if delete_success:
#Delete in local data-base
candidates = [
User.UserJSON(user) for user in self.users.find()
if user['_id'] == id
]
self.users.delete_many({"_id": id})
logger.getLogger().info("Successfully deleted user.")
else:
logger.getLogger().error(
"Attempted to delete user with non-existent id.")
return ResponseMaker.response_error(status_code, "Delete error")
return ResponseMaker.response_object(constants.DELETE_SUCCESS,
['user'], candidates)
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 get(self, userId, carId):
logger.getLogger().debug("GET at /users/" + str(userId) + "/carId/" +
str(carId))
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
print(decoded)
if not valid or (decoded['_id'] != userId):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
car = [
] #[ car for car in self.users.find( { $and: [ { "_id": { $eq : userId} }, { "cars._id": { $eq : carId } } ] } , { cars : 1 } ) if car["_id"]==carId ]
try:
if (len(car) == 0):
status_code, car = ServerRequest.getUserCar(userId, carId)
return ResponseMaker.response_object(constants.SUCCESS, ['car'],
car["properties"])
except Exception as e:
return ResponseMaker.response_error(constants.ERROR,
"Unexpected error")
def post(self):
print(request.json)
logger.getLogger().debug("POST at /trips/estimation")
logger.getLogger().debug(request.json)
try:
# (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")
#Send trip estimation request to shared server.
(status, response) = ServerRequest.estimateTrip(request.json)
if (status != constants.SUCCESS):
return ResponseMaker.response_error(status,
response["message"])
return ResponseMaker.response_object(status, ["cost"], [response])
except Exception as e:
logger.getLogger().error("Error " + str(e))
return ResponseMaker.response_error(constants.ERROR,
"Unexpected error" + str(e))
def get(self, id):
logger.getLogger().debug("GET at /users/" + str(id))
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
print("GET at /user/id")
candidates = [user for user in self.users.find() if user['_id'] == id]
if len(candidates) == 0:
#If not available in local data-base, ask Shared-Server for user info.
(status, response) = ServerRequest.getUser(id)
if (status != constants.SUCCESS):
return ResponseMaker.response_error(status,
response["message"])
candidates = [response]
user = candidates[0]
self.users.insert_one(user)
if len(candidates) == 0:
logger.getLogger().error(
"Attempted to retrieve user with non-existent id.")
return ResponseMaker.response_error(constants.NOT_FOUND,
"User id not found:" + str(e))
return ResponseMaker.response_object(constants.SUCCESS, ['user'],
[User.UserJSON(candidates[0])])
def post(self):
logger.getLogger().debug("POST at /directions")
logger.getLogger().debug(request.json)
print(request.json)
# Check user validity
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
if not valid:
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden")
# Check endpoints are in the request
if not request.json:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing parameters")
if not "origin" in request.json or not "destination" in request.json:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request")
origin = request.json['origin']
destination = request.json['destination']
# Check for coordinates on endpoints
if not "lat" in origin or not "lng" in origin:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request")
if not "lat" in destination or not "lng" in destination:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request")
origin_str = "origin=" + str(origin["lat"]) + "," + str(origin["lng"])
print("origin_str = " + origin_str)
destination_str = "destination=" + str(destination["lat"]) + "," + str(destination["lng"])
r = requests.get(GOOGLE_DIRECTIONS + "?" + origin_str + "&" + destination_str + "&key=" + GOOGLE_API_KEY)
r = r.json()
print(r)
if r["status"] != "OK":
return ResponseMaker.response_error(500, "Google API error: " + r["status"])
r = self.convert_response(r)
trip = {}
trip["directions"] = r
trip["driverId"] = -1
trip["passengerId"] = decoded["_id"]
# (shared) Ask shared for a trip cost estimation
try:
(status_code, response) = ServerRequest.estimateTrip(TripStates.trip_to_shared(trip))
except Exception as e:
logger.getLogger().exception("No cost estimation from server: " + str(e))
if not status_code == constants.SUCCESS:
logger.getLogger().exception("No cost estimation from server: " + str(e))
cost = {}
else:
cost = response["cost"]
return ResponseMaker.response_object(200, ["directions", "cost"], [r, cost])
def put(self, id):
print(id)
print("PUT at /user/" + str(id) + "/rating")
logger.getLogger().debug("PUT at /users/" + str(id) + "/rating")
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
try:
new_score = request.json["rate"]
rating_count = [
user["rating"]["rateCount"] for user in self.users.find()
if user['_id'] == id and user['type'] == "driver"
][0]
current_rate = [
user["rating"]["rate"] for user in self.users.find()
if user['_id'] == id and user['type'] == "driver"
][0]
if len(rating_count) == 0 and len(current_rate) == 0:
return ResponseMaker.response_error(constants.NOT_FOUND,
"User id not found.")
#Recalculate rating
rating_count += 1
current_rate = current_rate + new_score
#Update in local data-base
self.users.update({'_id': id}, {
"$set": {
"rating.rateCount": rating_count,
"rating.rate": current_rate
}
},
upsert=True)
logger.getLogger().info("Successfully updated driver rating")
driver = [
user for user in self.users.find()
if user['_id'] == id and user['type'] == "driver"
][0]
return ResponseMaker.response_object(constants.SUCCESS, ['rating'],
[User.RatingUserJSON(driver)])
except ValueError as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.UPDATE_CONFLICT,
"User update failed:" + str(e))
except requests.exceptions.Timeout as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.REQ_TIMEOUT,
"User update failed:" + str(e))
except Exception as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.ERROR, str(e))
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):
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 get(self, id):
logger.getLogger().debug("GET at /users/" + str(id) + "/rating")
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
try:
print("GET at /users/" + str(id) + "/rating")
candidates = [
user for user in self.users.find() if user['_id'] == id
]
if len(candidates) == 0:
#If not available in local data-base, ask Shared-Server for user info.
(status, response) = ServerRequest.getUser(id)
if (status != constants.SUCCESS):
return ResponseMaker.response_error(
status, response["message"])
candidates = [response]
if len(candidates) == 0:
logger.getLogger().error(
"Attempted to retrieve user with non-existent id.")
return ResponseMaker.response_error(
constants.NOT_FOUND, "User id not found:" + str(e))
if candidates[0]["type"] != "driver":
return ResponseMaker.response_error(
constants.PARAMERR,
"The requested user is not a driver. Only drivers receive ratings."
)
return ResponseMaker.response_object(
constants.SUCCESS, ['rating'],
[User.RatingUserJSON(candidates[0])])
except Exception as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.ERROR, str(e))
def put(self, id):
print(id)
print("PUT at /user/" + str(id) + "/loacation")
logger.getLogger().debug("PUT at /users/" + str(id) + "/location")
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
try:
updated_location = request.json["coord"]
#Update in local data-base
self.users.update({'_id': id},
{"$set": {
"coord": updated_location
}})
logger.getLogger().info("Successfully updated user location")
user = list(self.users.find({"_id": id}))[0]
if not user["tripId"] == "" and user["type"] == "driver":
## Need to update the trip!
TripStates.updateDriverLocation(user["tripId"], user)
return ResponseMaker.response_object(constants.SUCCESS,
['location'],
[updated_location])
except ValueError as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.UPDATE_CONFLICT,
"User update failed:" + str(e))
except requests.exceptions.Timeout as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.REQ_TIMEOUT,
"User update failed:" + str(e))
except Exception as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.ERROR, str(e))
def delete(self, userId, carId):
print("DELETE at /users/id")
logger.getLogger().debug("DELETE at /users/" + str(userId) + "/cars/" +
str(carId))
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
print(decoded)
if not valid or (decoded['_id'] != userId):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
try:
#Ask Shared-Server to delete this user
delete_success, status_code = ServerRequest.deleteUserCar(
userId, carId)
if delete_success:
#Delete in local data-base
self.users.update({"_id": id},
{'$pull': {
"cars": {
"_id": carId
}
}})
logger.getLogger().info("Successfully deleted user car.")
return ResponseMaker.response_object(constants.DELETE_SUCCESS,
['car'], {"id": carId})
else:
logger.getLogger().error(
"Attempted to delete car with non-existent id.")
return ResponseMaker.response_error(status_code,
"Delete error")
except Exception as e:
print(str(e))
return ResponseMaker.response_error(constants.ERROR,
"Unexpected error")
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 get(self, id):
logger.getLogger().debug("GET at /users/" + str(id) + "/transactions")
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR, "Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
print(decoded)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN, "Forbidden")
transactions = []#TODO:try fetch transactions from local database
try:
if (len(transactions) == 0):
status_code, transactions = ServerRequest.getUserTransactions(id)
except Exception as e:
return ResponseMaker.response_error(constants.NOT_FOUND, "User id did not match any existing users." + str(e))
return ResponseMaker.response_object(constants.SUCCESS, ['transactions'], [transactions])
def get(self):
logger.getLogger().debug("GET at /payment")
# (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")
status_code, response = ServerRequest.getPaymethods()
if (status_code != constants.SUCCESS):
return ResponseMaker.response_object(constants.ERROR, response['message'])
print(response)
return ResponseMaker.response_object(constants.SUCCESS, ['paymethods'], [response['paymethods']])
def put(self, id):
print(id)
print("PUT at /user/id")
logger.getLogger().debug("PUT at /users/" + str(id))
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
try:
#Ask Shared-Server to update this user
success, updated_user = ServerRequest.updateUser(request.json)
if success:
#Update in local data-base
self.users.update({'_id': updated_user['id']},
User.UserJSON(updated_user),
upsert=True)
logger.getLogger().info("Successfully updated user")
return ResponseMaker.response_error(
constants.SUCCESS, "User updated successfully!")
return ResponseMaker.response_error(constants.NOT_FOUND,
"User not found!")
except ValueError as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.UPDATE_CONFLICT,
"User update failed:" + str(e))
except requests.exceptions.Timeout as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.REQ_TIMEOUT,
"User update failed:" + str(e))
except Exception as e:
logger.getLogger().error(str(e))
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden: " + str(e))
def post(self, id):
print(request.json)
logger.getLogger().debug("POST at /users/cars")
logger.getLogger().debug(request.json)
try:
if not "UserToken" in request.headers:
return ResponseMaker.response_error(
constants.PARAMERR, "Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
print(decoded)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.FORBIDDEN,
"Forbidden")
#Create car at shared server.
(status, response) = ServerRequest.createUserCar(id, request.json)
if (status != constants.CREATE_SUCCESS):
return ResponseMaker.response_error(status,
response["message"])
#Update local database
car = response
car["_id"] = car.pop("id")
self.users.update({"_id": id}, {"$push": {"cars": car}})
return ResponseMaker.response_object(status, ["car"], [car])
except Exception as e:
logger.getLogger().debug(str(e))
print(str(e))
return ResponseMaker.response_error(constants.ERROR,
"Unexpected error: " + str(e))
def get(self, id):
logger.getLogger().debug("GET at /users/" + str(id) + "/trips")
if not "UserToken" in request.headers:
return ResponseMaker.response_error(constants.PARAMERR,
"Bad request - missing token")
token = request.headers['UserToken']
(valid, decoded) = TokenGenerator.validateToken(token)
if not valid or (decoded['_id'] != id):
return ResponseMaker.response_error(constants.UNAUTHORIZED,
"Unauthorized")
print("GET at /user/id/trips")
#Search local database
trips = [] #[user for user in self.users.find() if user['_id'] == id]
if len(trips) == 0:
#If not available in local data-base, ask Shared-Server for user info.
(status, response) = ServerRequest.getUserTrips(id)
if (status != constants.SUCCESS):
return ResponseMaker.response_error(status,
response["message"])
#TODO: fetch user from ss and store locally
trips = response
if (status == constants.NOT_FOUND):
logger.getLogger().error(
"Attempted to retrieve non-existent user trip list.")
return ResponseMaker.response_error(constants.NOT_FOUND,
"Trip list not found.")
return ResponseMaker.response_object(constants.SUCCESS, ['trips'],
[trips])
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 test_invalid_decode(self):
token = "This is a fake token"
valid, decoded = TokenGenerator.validateToken(token)
assert ('Invalid token' in decoded)
assert (valid == False)
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"]])
def test_decoded_gives_same_payload(self):
payload = {"username": "******", "_id": 1}
token = TokenGenerator.generateToken(payload)
valid, decoded = TokenGenerator.validateToken(token)
assert (valid == True)
assert (decoded == payload)
