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"))