def post(self, id):
"""
Deletes available trip from database and
sets driver to not available
"""
token = request.headers['token']
if not gm.validate_token(token):
logging.error('Token inválido')
abort(401)
content = request.json
# try:
# js.validate(content, schema) #TODO Determinar schema
# except js.exceptions.ValidationError:
# logging.error('Argumentos ingresados inválidos')
# abort(400)
db.trips.update_one({'_id': content['trip_id']}, {
'$set': {
'driver': id,
'status': 'inProgress'
}
})
db.drivers.update_one({'_id': id}, {
'$set': {
'available': False
}
})
pass_id = db.trips.find_one({'_id': content['trip_id']})['passenger']
self.push_notification(id, pass_id)
return Response(status=201)
def get(self, id):
"""
Viajes disponibles mas cercanos para un driver
:param id:
:return lista de viajes con la informacion del pasajero:
"""
logging.info("[GET:/drivers/" + str(id) + "/trips] Available Trips.")
token = request.headers['token']
if gm.validate_token(token):
logging.info("[GET:/drivers/" + str(id) + "/trips] El token es correcto")
# puede ingresar opcionalmente por parametro el radio de busqueda de los viajes en km
# sino por default son 2 km
# distance = request.args['max_distance']
# if distance: self.max_distance = distance
try:
driver = db.drivers.find_one({'_id': id})
except db.errors.ConnectionFailure:
logging.error('[GET:/drivers/' + str(id) + '/trips] Fallo de conexion con la base de datos')
abort(500)
if self._is_valid_user(driver):
respuesta = self._get_trips(driver)
logging.info('[GET:/drivers/' + str(id) + '/trips] Todo salio correcto')
return make_response(jsonify(trips=respuesta, token=token), 200)
logging.error('[GET:/drivers/' + str(id) + '/trips] Usuario no conectado')
abort(404)
else:
logging.error('[GET:/drivers/' + str(id) + '/trips] Token invalido')
abort(401)
def post(self, id):
"""
Updates waiting time and start time
"""
token = request.headers['token']
if not gm.validate_token(token):
logging.error('Token inválido')
abort(401)
content = request.json
paymethod = content['paymethod']
trip = db.trips.find_one({'_id': id})
if paymethod == 'cash':
properties = {'method': 'cash'}
elif paymethod == 'card':
properties = self.get_card(trip['passenger'])
else:
logging.error('Parámetro paymethod incorrecto: ' + paymethod)
abort(400)
start_datetime = datetime.datetime.strptime(trip['startTime'], "%Y-%m-%d %H:%M:%S")
trip_time = datetime.datetime.now() - start_datetime
trip_time = round(trip_time.total_seconds())
cost = self.get_cost(trip['distance'], trip_time, paymethod, start_datetime, trip['startTime'])
self.post_trip(trip, cost, trip_time, paymethod, properties)
self.update_db(trip)
gm.push_notif(trip['driver'], "Viaje terminado", "Esperamos que haya disfrutado su viaje")
return {'cost': cost}, 201
def get(self, id):
"""
Choferes mas cercanos para un passenger
:param id:
:return lista con la informacion de los choferes:
"""
logging.info("[GET:/passengers/" + str(id) + "/drivers] Available Drivers.")
token = request.headers['token']
if gm.validate_token(token):
logging.info("[GET:/passengers/" + str(id) + "/drivers] El token es correcto")
# puede ingresar opcionalmente por parametro el radio de busqueda de los viajes en km
# sino por default son 2 km
# distance = request.args['max_distance']
# if distance: self.max_distance = distance
try:
passenger = db.passengers.find_one({'_id': id})
except db.errors.ConnectionFailure:
logging.error('[GET:/passengers/' + str(id) + '/drivers] Fallo de conexion con la base de datos')
abort(500)
if self._is_valid_user(passenger):
response = {}
response['drivers'] = self._get_closer_drivers(passenger)
response['token'] = token
logging.info('[GET:/passengers/' + str(id) + '/drivers] Todo salio correcto')
return make_response(jsonify(response), 200)
logging.error('[GET:/passengers/' + str(id) + '/drivers] Usuario no conectado')
abort(404)
logging.error('[GET:/passengers/' + str(id) + '/drivers] Token invalido')
abort(401)
def get(self, id):
token = request.headers['token']
if not gm.validate_token(token, id):
logging.error('Token invalido')
abort(401)
service = gets.Get()
return service.get(ss.URL + '/users/' + repr(id) + '/card')['card']
def post(self, id):
"""
Permite que el usuario cierre sesion
:param id:
:return:
"""
logging.info("[POST:/users/" + str(id) + "/logout] LogOut.")
token = request.headers['token']
if gm.validate_token(token, id):
logging.info("[POST:/passengers/" + str(id) +
"/drivers] El token es correcto")
try:
db.drivers.update_one({'_id': id},
{'$set': {
'available': False
}})
except db.errors.ConnectionFailure:
logging.error(
'[POST:/users/' + str(id) +
'/logout] Fallo de conexion con la base de datos')
abort(500)
return Response(status=201)
logging.error('[POST:/users/' + str(id) + '/logout] Token invalido')
abort(401)
def get(self, id):
token = request.headers['token']
if not gm.validate_token(token, id):
logging.error('Token invalido')
abort(401)
service = gets.Get() #TODO: Validar que devuelva driver y no passenger
r = service.get(ss.URL + '/users/' + repr(id))
return gm.build_response(r)
def update_location(schema, collection, id):
token = request.headers['token']
if not gm.validate_token(token, id):
logging.error('Token inválido')
abort(401)
content = request.json
if not gm.validate_args(schema, content):
abort(400)
collection.update_one({'_id': id}, {
'$set': {
'lon': content['lon'],
'lat': content['lat']
}
})
def get(self, id, user_type):
logging.info("get Trip History")
token = request.headers['token']
if not gm.validate_token(token, id):
logging.error('Token inválido')
abort(401)
logging.info("Token correcto")
if user_type == 'passenger':
user = db.passengers.find_one({'_id': id})
else:
user = db.drivers.find_one({'_id': id})
if user:
respuesta = self._get_trips(id, user_type)
return make_response(jsonify(trips=respuesta, token=token), 200)
else:
logging.error('Id inexistente/no conectado')
abort(404)
def post(self, id):
token = request.headers['token']
if not gm.validate_token(token, id):
logging.error('Token inválido')
abort(401)
content = request.json
if not gm.validate_args(self.schema, content):
abort(400)
origindb = db.passengers.find_one({'_id': id})
if origindb is None:
logging.error('Id de usuario inexistente')
abort(404)
# origindb = {'lat': -34.5903345,
# 'lon': -58.4161065}
origin = str(origindb['lat']) + ',' + str(origindb['lon'])
destiny = str(content['lat']) + ',' + str(content['lon'])
directions = gmaps.directions(origin, destiny, alternatives=True)
return {'routes': directions}, 201
def put(self, id, endpoint, schema, type=None):
"""Permite modificar"""
token = request.headers['token']
if not gm.validate_token(token, id):
logging.error('Token invalido')
abort(401)
content = request.json
if not gm.validate_args(schema, content):
abort(400)
if type == 'user' or type == 'car':
content = self.add_ref(endpoint, content, type)
try:
r = requests.put(endpoint, json=content, headers={'token': 'superservercito-token'})
r.raise_for_status()
except requests.exceptions.HTTPError:
logging.error('Conexión con el Shared dio error en put: ' + repr(r.status_code))
print(r.json())
abort(r.status_code)
return r.json()
def post(self):
"""Estimar un valor de viaje propuesto"""
logging.info("post TripEstimate")
token = request.headers['token']
if gm.validate_token(token):
logging.info("token correcto")
content = request.get_json()
if self._is_valid_body_request(content):
query = self._filter_body(content)
response = self._send_query(query)
# todo: ver si solo le mando el costo o algo mas
return make_response(jsonify(cost=response['cost'], token=token), 201)
logging.error('Argumentos ingresados inválidos')
abort(400)
logging.error('Token invalido')
abort(401)
def post(self, id):
"""
Crear una soliciud e viaje.
:param id:
:return json con id del viaje solicitado:
"""
logging.info("[POST:/passengers/" + str(id) + "/trips/request] Trip Request.")
token = request.headers['token']
if gm.validate_token(token):
logging.info("[POST:/passengers/" + str(id) + "/trips/request] El token es correcto")
passenger = db.passengers.find_one({'_id': id})
if passenger:
logging.info("usuario correcto")
content = request.get_json()
try:
js.validate(content, self.schema)
except js.exceptions.ValidationError:
logging.error('[POST:/passengers/' + str(id) + '/trips/request] Argumentos ingresados inválidos')
abort(400)
# if self.is_passenger_alredy_has_some_trip_request():
trip = self._convert_to_trip(id, content)
self._add_trip_to_db(trip)
logging.info('[POST:/passengers/' + str(id) + '/trips/request] Todo salio correcto')
return make_response(jsonify(trip_id=trip['_id']), 201)
else:
logging.error('[POST:/passengers/' + str(id) + '/trips/request] Usuario no conectado')
abort(404)
else:
logging.error('[POST:/passengers/' + str(id) + '/trips/request] Token invalido')
abort(401)
def post(self, id):
"""
Updates waiting time and start time
"""
token = request.headers['token']
if not gm.validate_token(token):
logging.error('Token inválido')
abort(401)
trip = db.trips.find_one({'_id': id})
start_time = datetime.datetime.now()
start_time = start_time.strftime("%Y-%m-%d %H:%M:%S")
wait_time = datetime.datetime.now() - datetime.datetime.strptime(trip['waitTime'], "%Y-%m-%d %H:%M:%S")
wait_time = round(wait_time.total_seconds())
db.trips.update_one({'_id': id}, {
'$set': {
'waitTime': wait_time,
'startTime': start_time
}
})
return Response(status=201)
def test_validate_tokenId_NOK(self):
some_id = 12345679
token = gm.encode_token(some_id)
self.assertFalse(gm.validate_token(token, "1"))
def test_validate_tokenId_OK(self):
some_id = 12345679
token = gm.encode_token(some_id)
self.assertTrue(gm.validate_token(token, some_id))
def test_validate_token_NOK(self):
self.assertTrue(gm.validate_token("5"))