Ejemplo n.º 1
0
    def test_maps(self):
        """
        Ensure we can access the Maps list.
        """
        url = reverse('maps-list')
        # Anonymous
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(len(response.data), 5)
        self.assertEqual(response.data['total'], 9)
        # Pagination
        self.assertEqual(len(response.data['maps']), 9)
        logger.debug(response.data)

        for _l in response.data['maps']:
            self.assertTrue(_l['resource_type'], 'map')

        # Get Layers List (backgrounds)
        resource = Map.objects.first()

        url = urljoin(f"{reverse('maps-detail', kwargs={'pk': resource.pk})}/", 'layers/')
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, 200)
        layers_data = response.data
        self.assertIsNotNone(layers_data)

        # Get Local-Layers List (GeoNode)
        url = urljoin(f"{reverse('maps-detail', kwargs={'pk': resource.pk})}/", 'local_layers/')
        response = self.client.get(url, format='json')
        self.assertEqual(response.status_code, 200)
        layers_data = response.data
        self.assertIsNotNone(layers_data)

        if settings.GEONODE_CLIENT_LAYER_PREVIEW_LIBRARY == 'mapstore':
            url = reverse('resources-list')
            self.assertEqual(url, '/mapstore/rest/resources/')

            from mapstore2_adapter import fixup_map
            fixup_map(resource.id)
            # Anonymous
            response = self.client.get(url, format='json')
            self.assertEqual(response.status_code, 200)
            if response.data:
                self.assertEqual(len(response.data), 1)

                # Get Full MapStore layer configuration
                url = reverse('resources-detail', kwargs={'pk': resource.pk})
                response = self.client.get(f"{url}?full=true", format='json')
                self.assertEqual(response.status_code, 200)
                self.assertTrue(len(response.data) > 0)
                self.assertTrue('data' in response.data)
                self.assertTrue('attributes' in response.data)
Ejemplo n.º 2
0
    def convert(self, viewer, request):
        """
            input: GeoNode JSON Gxp Config
            output: MapStore2 compliant str(config)
        """
        # Initialization
        viewer_obj = json.loads(viewer)
        if isinstance(viewer_obj, str):
            viewer_obj = json.loads(viewer_obj)

        map_id = None
        if 'id' in viewer_obj and viewer_obj['id']:
            try:
                map_id = int(viewer_obj['id'])
            except Exception:
                pass

        data = {}
        data['version'] = 2

        # Map Definition
        try:
            # Map Definition
            ms2_map = {}
            ms2_map['projection'] = viewer_obj['map']['projection']
            ms2_map['units'] = viewer_obj['map']['units']
            ms2_map['zoom'] = viewer_obj['map'][
                'zoom'] if viewer_obj['map']['zoom'] > 0 else 2
            ms2_map['maxExtent'] = viewer_obj['map']['maxExtent']
            ms2_map['maxResolution'] = viewer_obj['map']['maxResolution']

            # Backgrouns
            backgrounds = self.getBackgrounds(viewer, MAP_BASELAYERS)
            if backgrounds:
                ms2_map['layers'] = backgrounds
            else:
                ms2_map['layers'] = MAP_BASELAYERS + [
                    # TODO: covnert Viewer Background Layers
                    # Add here more backgrounds e.g.:
                    # {
                    # 	"type": "wms",
                    # 	"url": "https://demo.geo-solutions.it/geoserver/wms",
                    # 	"visibility": True,
                    # 	"opacity": 0.5,
                    # 	"title": "Weather data",
                    # 	"name": "nurc:Arc_Sample",
                    # 	"group": "Meteo",
                    # 	"format": "image/png",
                    # 	"bbox": {
                    # 		"bounds": {
                    # 			"minx": -25.6640625,
                    # 			"miny": 26.194876675795218,
                    # 			"maxx": 48.1640625,
                    # 			"maxy": 56.80087831233043
                    # 		},
                    # 		"crs": "EPSG:4326"
                    # 	}
                    # }, ...
                ]

            if settings.BING_API_KEY:
                ms2_map['bingApiKey'] = settings.BING_API_KEY

            # Security Info
            info = {}
            info['canDelete'] = False
            info['canEdit'] = False
            info['description'] = viewer_obj['about']['abstract']
            info['id'] = map_id
            info['name'] = viewer_obj['about']['title']
            ms2_map['info'] = info

            # Overlays
            overlays, selected = self.get_overlays(viewer, request=request)
            if selected and 'name' in selected and selected[
                    'name'] and not map_id:
                # We are generating a Layer Details View
                center, zoom = self.get_center_and_zoom(
                    viewer_obj['map'], selected)
                ms2_map['center'] = center
                ms2_map['zoom'] = zoom

                try:
                    # - extract from GeoNode guardian
                    from geonode.layers.views import (_resolve_layer,
                                                      _PERMISSION_MSG_MODIFY,
                                                      _PERMISSION_MSG_DELETE)
                    if _resolve_layer(request, selected['name'],
                                      'base.change_resourcebase',
                                      _PERMISSION_MSG_MODIFY).user_can(
                                          request.user,
                                          'base.change_resourcebase'):
                        info['canEdit'] = True

                    if _resolve_layer(request, selected['name'],
                                      'base.delete_resourcebase',
                                      _PERMISSION_MSG_DELETE).user_can(
                                          request.user,
                                          'base.delete_resourcebase'):
                        info['canDelete'] = True
                except Exception:
                    tb = traceback.format_exc()
                    logger.debug(tb)
            else:
                # We are getting the configuration of a Map
                # On GeoNode model the Map Center is always saved in 4326
                _x = get_valid_number(viewer_obj['map']['center'][0])
                _y = get_valid_number(viewer_obj['map']['center'][1])
                _crs = 'EPSG:4326'
                if _x > 360.0 or _x < -360.0:
                    _crs = viewer_obj['map']['projection']
                ms2_map['center'] = {'x': _x, 'y': _y, 'crs': _crs}
                try:
                    # - extract from GeoNode guardian
                    from geonode.maps.views import (_resolve_map,
                                                    _PERMISSION_MSG_SAVE,
                                                    _PERMISSION_MSG_DELETE)
                    if _resolve_map(request, str(map_id),
                                    'base.change_resourcebase',
                                    _PERMISSION_MSG_SAVE).user_can(
                                        request.user,
                                        'base.change_resourcebase'):
                        info['canEdit'] = True

                    if _resolve_map(request, str(map_id),
                                    'base.delete_resourcebase',
                                    _PERMISSION_MSG_DELETE).user_can(
                                        request.user,
                                        'base.delete_resourcebase'):
                        info['canDelete'] = True
                except Exception:
                    tb = traceback.format_exc()
                    logger.debug(tb)

            for overlay in overlays:
                if 'name' in overlay and overlay['name']:
                    ms2_map['layers'].append(overlay)

            data['map'] = ms2_map
        except Exception:
            # traceback.print_exc()
            tb = traceback.format_exc()
            logger.debug(tb)

        # Additional Configurations
        if map_id:
            from mapstore2_adapter import fixup_map
            from mapstore2_adapter.api.models import MapStoreResource
            try:
                fixup_map(map_id)
                ms2_resource = MapStoreResource.objects.get(id=map_id)
                ms2_map_data = ms2_resource.data.blob
                if isinstance(ms2_map_data, string_types):
                    ms2_map_data = json.loads(ms2_map_data)
                if 'map' in ms2_map_data:
                    for _k, _v in ms2_map_data['map'].items():
                        if _k not in data['map']:
                            data['map'][_k] = ms2_map_data['map'][_k]
                    del ms2_map_data['map']
                data.update(ms2_map_data)
            except Exception:
                # traceback.print_exc()
                tb = traceback.format_exc()
                logger.debug(tb)

        # Default Catalogue Services Definition
        try:
            ms2_catalogue = {}
            ms2_catalogue['selectedService'] = CATALOGUE_SELECTED_SERVICE
            ms2_catalogue['services'] = CATALOGUE_SERVICES
            data['catalogServices'] = ms2_catalogue
        except Exception:
            # traceback.print_exc()
            tb = traceback.format_exc()
            logger.debug(tb)

        json_str = json.dumps(data, cls=DjangoJSONEncoder, sort_keys=True)
        for (c, d) in unsafe_chars.items():
            json_str = json_str.replace(c, d)

        return json_str