Esempio n. 1
0
    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)
Esempio n. 2
0
    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)
Esempio n. 3
0
    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
Esempio n. 4
0
    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']
Esempio n. 6
0
    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)
Esempio n. 7
0
 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)
Esempio n. 8
0
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']
                                 }
                            })
Esempio n. 9
0
    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)
Esempio n. 10
0
    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
Esempio n. 11
0
    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()
Esempio n. 12
0
    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)
Esempio n. 13
0
    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)
Esempio n. 14
0
    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"))