Exemplo n.º 1
0
    def capabilities(self, map_request):
        # TODO: debug layer
        # if '__debug__' in map_request.params:
        #     layers = self.layers.values()
        # else:
        #     layers = [layer for name, layer in self.layers.iteritems()
        #               if name != '__debug__']

        if map_request.params.get("tiled", "false").lower() == "true":
            tile_layers = self.tile_layers.values()
        else:
            tile_layers = []

        service = self._service_md(map_request)
        root_layer = self.authorized_capability_layers(map_request.http.environ)

        info_types = ["text", "html", "xml"]  # defaults
        if self.info_types:
            info_types = self.info_types
        elif self.fi_transformers:
            info_types = self.fi_transformers.keys()
        info_formats = [mimetype_from_infotype(map_request.version, info_type) for info_type in info_types]
        result = Capabilities(
            service, root_layer, tile_layers, self.image_formats, info_formats, srs=self.srs, bbox_srs=self.bbox_srs
        ).render(map_request)
        return Response(result, mimetype=map_request.mime_type)
Exemplo n.º 2
0
    def capabilities(self, map_request):
        # TODO: debug layer
        # if '__debug__' in map_request.params:
        #     layers = self.layers.values()
        # else:
        #     layers = [layer for name, layer in self.layers.iteritems()
        #               if name != '__debug__']

        if map_request.params.get('tiled', 'false').lower() == 'true':
            tile_layers = self.tile_layers.values()
        else:
            tile_layers = []

        service = self._service_md(map_request)
        root_layer = self.authorized_capability_layers(
            map_request.http.environ)

        info_types = ['text', 'html', 'xml']  # defaults
        if self.info_types:
            info_types = self.info_types
        elif self.fi_transformers:
            info_types = self.fi_transformers.keys()
        info_formats = [
            mimetype_from_infotype(map_request.version, info_type)
            for info_type in info_types
        ]
        result = Capabilities(service,
                              root_layer,
                              tile_layers,
                              self.image_formats,
                              info_formats,
                              srs=self.srs,
                              bbox_srs=self.bbox_srs).render(map_request)
        return Response(result, mimetype=map_request.mime_type)
Exemplo n.º 3
0
    def featureinfo(self, request):
        infos = []
        self.check_featureinfo_request(request)

        p = request.params
        query = InfoQuery(p.bbox,
                          p.size,
                          SRS(p.srs),
                          p.pos,
                          p['info_format'],
                          format=request.params.format or None,
                          feature_count=p.get('feature_count'))

        actual_layers = odict()

        for layer_name in request.params.query_layers:
            layer = self.layers[layer_name]
            if not layer.queryable:
                raise RequestError('layer %s is not queryable' % layer_name,
                                   request=request)
            for layer_name, info_layers in layer.info_layers_for_query(query):
                actual_layers[layer_name] = info_layers

        authorized_layers, coverage = self.authorized_layers(
            'featureinfo',
            actual_layers.keys(),
            request.http.environ,
            query_extent=(query.srs.srs_code, query.bbox))
        self.filter_actual_layers(actual_layers, request.params.layers,
                                  authorized_layers)

        # outside of auth-coverage
        if coverage and not coverage.contains(query.coord, query.srs):
            infos = []
        else:
            info_layers = []
            for layers in actual_layers.values():
                info_layers.extend(layers)

            for layer in info_layers:
                info = layer.get_info(query)
                if info is None:
                    continue
                infos.append(info)

        mimetype = None
        if 'info_format' in request.params:
            mimetype = request.params.info_format

        if not infos:
            return Response('', mimetype=mimetype)

        if self.fi_transformers:
            doc = infos[0].combine(infos)
            if doc.info_type == 'text':
                resp = doc.as_string()
                mimetype = 'text/plain'
            else:
                if not mimetype:
                    if 'xml' in self.fi_transformers:
                        info_type = 'xml'
                    elif 'html' in self.fi_transformers:
                        info_type = 'html'
                    else:
                        info_type = 'text'
                    mimetype = mimetype_from_infotype(request.version,
                                                      info_type)
                else:
                    info_type = infotype_from_mimetype(request.version,
                                                       mimetype)
                resp = self.fi_transformers[info_type](doc).as_string()
        else:
            mimetype = mimetype_from_infotype(request.version,
                                              infos[0].info_type)
            if len(infos) > 1:
                resp = infos[0].combine(infos).as_string()
            else:
                resp = infos[0].as_string()

        return Response(resp, mimetype=mimetype)
Exemplo n.º 4
0
    def featureinfo(self, request):
        infos = []
        self.check_featureinfo_request(request)

        p = request.params
        query = InfoQuery(
            p.bbox,
            p.size,
            SRS(p.srs),
            p.pos,
            p["info_format"],
            format=request.params.format or None,
            feature_count=p.get("feature_count"),
        )

        actual_layers = odict()

        for layer_name in request.params.query_layers:
            layer = self.layers[layer_name]
            if not layer.queryable:
                raise RequestError("layer %s is not queryable" % layer_name, request=request)
            for layer_name, info_layers in layer.info_layers_for_query(query):
                actual_layers[layer_name] = info_layers

        authorized_layers, coverage = self.authorized_layers(
            "featureinfo", actual_layers.keys(), request.http.environ, query_extent=(query.srs.srs_code, query.bbox)
        )
        self.filter_actual_layers(actual_layers, request.params.layers, authorized_layers)

        # outside of auth-coverage
        if coverage and not coverage.contains(query.coord, query.srs):
            infos = []
        else:
            info_layers = []
            for layers in actual_layers.values():
                info_layers.extend(layers)

            for layer in info_layers:
                info = layer.get_info(query)
                if info is None:
                    continue
                infos.append(info)

        mimetype = None
        if "info_format" in request.params:
            mimetype = request.params.info_format

        if not infos:
            return Response("", mimetype=mimetype)

        if self.fi_transformers:
            doc = infos[0].combine(infos)
            if doc.info_type == "text":
                resp = doc.as_string()
                mimetype = "text/plain"
            else:
                if not mimetype:
                    if "xml" in self.fi_transformers:
                        info_type = "xml"
                    elif "html" in self.fi_transformers:
                        info_type = "html"
                    else:
                        info_type = "text"
                    mimetype = mimetype_from_infotype(request.version, info_type)
                else:
                    info_type = infotype_from_mimetype(request.version, mimetype)
                resp = self.fi_transformers[info_type](doc).as_string()
        else:
            mimetype = mimetype_from_infotype(request.version, infos[0].info_type)
            if len(infos) > 1:
                resp = infos[0].combine(infos).as_string()
            else:
                resp = infos[0].as_string()

        return Response(resp, mimetype=mimetype)