def test_combine_mixed(self):
        docs = [
            JSONFeatureInfoDoc(b'{"results": [{"foo": 1}]}'),
            TextFeatureInfoDoc(b"Plain Text"),
        ]
        result, infotype = combine_docs(docs, None)

        assert b"""{"results": [{"foo": 1}]}\nPlain Text""" == result
        assert infotype == "text"
    def test_combine_xml(self):
        docs = [
            XMLFeatureInfoDoc("<root><a>foo</a></root>"),
            XMLFeatureInfoDoc("<root><b>bar</b></root>"),
        ]
        result, infotype = combine_docs(docs, None)

        assert b"""<root><a>foo</a><b>bar</b></root>""" == result
        assert infotype == "xml"
    def test_combine_json(self):
        docs = [
            JSONFeatureInfoDoc("{}"),
            JSONFeatureInfoDoc('{"results": [{"foo": 1}]}'),
            JSONFeatureInfoDoc('{"results": [{"bar": 2}]}'),
        ]
        result, infotype = combine_docs(docs, None)

        assert """{"results": [{"foo": 1}, {"bar": 2}]}""" == result
        assert infotype == "json"
Exemple #4
0
    def featureinfo(self, request):
        infos = []
        self.check_request(request, self.info_formats)

        tile_layer = self.layers[request.layer][request.tilematrixset]
        if not request.format:
            request.format = tile_layer.format

        bbox = tile_layer.grid.tile_bbox(request.tile)
        query = InfoQuery(
            bbox,
            tile_layer.grid.tile_size,
            tile_layer.grid.srs,
            request.pos,
            request.infoformat,
        )

        self.check_request_dimensions(tile_layer, request)

        coverage = self.authorize_tile_layer(tile_layer,
                                             request,
                                             featureinfo=True)

        if not tile_layer.info_sources:
            raise RequestError('layer %s not queryable' % str(request.layer),
                               code='OperationNotSupported',
                               request=request)

        if coverage and not coverage.contains(query.coord, query.srs):
            infos = []
        else:
            for source in tile_layer.info_sources:
                info = source.get_info(query)
                if info is None:
                    continue
                infos.append(info)

        mimetype = request.infoformat

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

        resp, _ = combine_docs(infos)

        return Response(resp, mimetype=mimetype)
    def test_combine_transform_xml(self, tmpdir):
        xsl = tmpdir.join("transform.xsl")
        xsl.write("""<xsl:stylesheet version="1.0"
         xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
         <xsl:template match="/">
            <root>
                <xsl:apply-templates select='/a/b'/>
            </root>
         </xsl:template>
         <xsl:template match="/a/b">
             <foo><xsl:value-of select="text()" /></foo>
         </xsl:template>
        </xsl:stylesheet>
        """)
        transf = XSLTransformer(xsl.strpath)
        docs = [
            XMLFeatureInfoDoc("<a><b>foo1</b></a>"),
            XMLFeatureInfoDoc("<a><b>foo2</b></a>"),
        ]
        result, infotype = combine_docs(docs, transf)

        assert b"""<root><foo>foo1</foo><foo>foo2</foo></root>""" == result
        assert infotype is None
Exemple #6
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:
            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, actual_info_type = combine_docs(
                infos, self.fi_transformers[info_type])
            if actual_info_type is not None and info_type != actual_info_type:
                mimetype = mimetype_from_infotype(request.version,
                                                  actual_info_type)
        else:
            resp, info_type = combine_docs(infos)
            mimetype = mimetype_from_infotype(request.version, info_type)

        return Response(resp, mimetype=mimetype)