示例#1
0
    def addpothole(self, lat, lon, user, report_type):
        nowtime = int(time.time())
        # Add pothole
        new_pothole = Pothole()
        new_pothole._set_location(lat, lon)
        #new_pothole._set_latitude(lat)
        #new_pothole._set_longitude(lon)
        # -- UTF-8 issue anchor --
        new_pothole.update_location()
        new_pothole.case_status = "Open"
        new_pothole.report_type = report_type
        new_pothole.time = nowtime
        new_pothole.put()

        # Add potholelog
        new_pothole_log = PotholeReportLog()
        new_pothole_log.user = user
        new_pothole_log.message = "User "+user+" add a pothole @lat:"+str(lat)+" lon:"+str(lon)
        new_pothole_log.time = nowtime
        new_pothole_log.put()
示例#2
0
    def get(self):
        # Working json code
        callback = self.request.get('callback')     #jsonp call back
        """
        request_time = self.request.get("time")
        json_type = self.request.get("jsontype")
        urlobject = urlparse.urlparse(self.request.url)
        baseurl = urlparse.urlunparse((urlobject.scheme, urlobject.netloc, '', '', '', ''))

        db_time = 0
        if request_time.isdigit():
            db_time = int(request_time)

        potholeDB = db.GqlQuery(
                    "SELECT report_type,case_status,time,location FROM Pothole "
                    "WHERE time > :dbtime "
                    "ORDER by time DESC ",
                    dbtime = db_time
                )
        potholeResults = potholeDB.fetch(100)
        output = []
        icon_preset = dict(
                iconUrl = baseurl + "/assets/img/pothole-sign.png",
                iconSize = [30, 30],
                iconAnchor =  [15, 15],
                popupAnchor = [0, -15],
                className = "dot"
            )
        icon_twilio = dict (
                iconUrl = baseurl + "/assets/img/pothole-twilio.png",
                iconSize = [30, 30],
                iconAnchor =  [15, 15],
                popupAnchor = [0, -15],
                className = "dot"
            )
        icon_contextio = dict (
                iconUrl = baseurl + "/assets/img/pothole-contextio.png",
                iconSize = [30, 30],
                iconAnchor =  [15, 15],
                popupAnchor = [0, -15],
                className = "dot"
            )
        if json_type == "geojson":
            for pothole in potholeResults:
                if pothole.report_type == "twilio":
                    icon_set = icon_twilio
                elif pothole.report_type == "contextio":
                    icon_set = icon_contextio
                else:
                    icon_set = icon_preset
                pothole_json = dict(
                    time = str(pothole.time),
                    type = "Feature",
                    geometry =  dict(
                        type = "Point",
                        coordinates = [pothole.location.lon, pothole.location.lat]
                    ),
                    properties = dict(
                        title = "Pothole",
                        icon = icon_set
                    )
                )
                output.append(pothole_json)
        else :
            # Regular json type for us to read
            for pothole in potholeResults:
                pothole_json = dict(
                        lat      = pothole.location.lat,
                        lon      = pothole.location.lon,
                        case_status = str(pothole.case_status),
                        report_type = str(pothole.report_type),
                        time = str(pothole.time)
                    )
                output.append(pothole_json)

        self.response.out.write(self.json_output(output, callback))

        return
        """
        #
        #
        # approximately search
        try:
            center = geotypes.Point(float(self.request.get('lat')),float(self.request.get('lon')))
        except ValueError:
            json_result = dict(
                status = 'error',
                message = 'lat and lon parameters must be valid latitude and longitude values.'
            )
            return self.response.out.write(self.json_output(json_result, callback))

        max_results = 100
        if self.request.get('maxresults'):
          max_results = int(self.request.get('maxresults'))
        
        max_distance = 8000 # 80 km ~ 50 mi
        if self.request.get('maxdistance'):
          max_distance = float(self.request.get('maxdistance'))

        # Query start
        base_query = Pothole.all()
        results = Pothole.proximity_fetch(
            base_query,
            center, max_results=max_results, max_distance=max_distance)

        public_attrs = Pothole.public_attributes()
        results_obj = [
          _merge_dicts({
            'lat': result.location.lat,
            'lon': result.location.lon,
            },
            {'case_status': str(result.case_status),
             'id': str(result.key().id()),
             'report_type': str(result.report_type),
            })
            #{dict([(attr, getattr(result, attr))
            #                  for attr in public_attrs])})
          for result in results]

        json_result = dict(
            status = 'success',
            total = str(len(results)),
            results = results_obj
        )
        self.response.out.write(self.json_output(json_result, callback))