def _update_layer_data(body, last_message):
message = json.loads(body)
workspace = message["source"]["workspace"] if "workspace" in message["source"] else None
store = message["source"]["store"] if "store" in message["source"] else None
filter = message["source"]["name"]
update_layer = False
if not last_message:
last_message = message
update_layer = True
else:
last_workspace = message["source"]["workspace"] if "workspace" in message["source"] else None
last_store = message["source"]["store"] if "store" in message["source"] else None
last_filter = last_message["source"]["name"]
if (last_workspace, last_store, last_filter) != (workspace, store, filter):
update_layer = True
else:
timestamp_t1 = datetime.strptime(last_message["timestamp"], '%Y-%m-%dT%H:%MZ')
timestamp_t2 = datetime.strptime(message["timestamp"], '%Y-%m-%dT%H:%MZ')
timestamp_delta = timestamp_t2 - timestamp_t1
if timestamp_t2 > timestamp_t1 and timestamp_delta.seconds > 60:
update_layer = True
if update_layer:
gs_slurp(False, workspace=workspace, store=store, filter=filter, remove_deleted=True, execute_signals=True)
def _update_layer_data(body, last_message):
message = json.loads(body)
workspace = message["source"]["workspace"] if "workspace" in message[
"source"] else None
store = message["source"]["store"] if "store" in message["source"] else None
filter = message["source"]["name"]
update_layer = False
if not last_message:
last_message = message
update_layer = True
last_workspace = message["source"]["workspace"] if "workspace" in message[
"source"] else None
last_store = message["source"]["store"] if "store" in message[
"source"] else None
last_filter = last_message["source"]["name"]
if (last_workspace, last_store, last_filter) != (workspace, store, filter):
update_layer = True
else:
timestamp_t1 = datetime.strptime(last_message["timestamp"],
'%Y-%m-%dT%H:%MZ')
timestamp_t2 = datetime.strptime(message["timestamp"],
'%Y-%m-%dT%H:%MZ')
timestamp_delta = timestamp_t2 - timestamp_t1
if timestamp_t2 > timestamp_t1 and timestamp_delta.seconds > 60:
update_layer = True
if update_layer:
gs_slurp(True,
workspace=workspace,
store=store,
filter=filter,
remove_deleted=True,
execute_signals=True)
def _create_geoserver_geonode_layer(new_table, sld_type, title, the_user,
permissions):
# Create the Layer in GeoServer from the table
try:
cat = Catalog(settings.OGC_SERVER['default']['LOCATION'] + "rest",
settings.OGC_SERVER['default']['USER'],
settings.OGC_SERVER['default']['PASSWORD'])
ds = cat.get_store("uploaded") # name of store in WFP-Geonode
cat.publish_featuretype(new_table, ds, "EPSG:4326", srs="EPSG:4326")
# changing the layer's title in the title set by the user
resource = cat.get_resource(new_table, workspace="geonode")
resource.title = title
cat.save(resource)
except Exception as e:
msg = "Error creating GeoServer layer for %s: %s" % (new_table, str(e))
print msg
return None, msg
# Create the Layer in GeoNode from the GeoServer Layer
try:
link_to_sld = "{location}styles/{sld_type}".format(
**{
'location': settings.OGC_SERVER['default']['LOCATION'],
'sld_type': sld_type
})
r = requests.get(link_to_sld)
sld = r.text
sld = sld.replace(
"name_of_layer", new_table
) # "name_of_layer" is set in the predefined sld in geoserver (polygon_style, line_style, point_style)
cat.create_style(new_table, sld, overwrite=True)
style = cat.get_style(new_table)
layer = cat.get_layer(new_table)
layer.default_style = style
cat.save(layer)
gs_slurp(owner=the_user, filter=new_table)
from geonode.base.models import ResourceBase
layer = ResourceBase.objects.get(title=title)
geoserver_post_save(layer, ResourceBase)
# assign permissions for this layer
permissions_dict = json.loads(permissions) # needs to be dictionary
if permissions_dict is not None and len(permissions_dict.keys()) > 0:
layer.set_permissions(permissions_dict)
except Exception as e:
msg = "Error creating GeoNode layer for %s: %s" % (new_table, str(e))
return None, msg
def handle(self, layer, layer_config, *args, **kwargs):
"""
Adds a layer in GeoNode, after it has been added to Geoserver.
Handler specific params:
"layer_owner": Sets the owner of the layer.
"""
owner = layer_config.get('layer_owner')
if isinstance(owner, str) or isinstance(owner, unicode):
owner = User.objects.filter(username=owner).first()
if re.search(r'\.tif$', layer):
store_name = os.path.splitext(os.path.basename(layer))[0]
filter = None
else:
store_name = self.store_name
filter = layer
results = gs_slurp(workspace=self.workspace,
store=store_name,
filter=filter,
owner=owner,
permissions=layer_config.get('permissions'))
if self.importer.upload_file and results['layers'][0]['status'] == 'created':
matched_layer = Layer.objects.get(name=results['layers'][0]['name'])
upload_layer = UploadLayer.objects.get(upload=self.importer.upload_file.upload,
index=layer_config.get('index'))
upload_layer.layer = matched_layer
upload_layer.save()
return results
def update_geonode_layers(**kwargs):
"""
Runs update layers.
"""
from geonode.geoserver.helpers import gs_slurp
from geonode.people.models import Profile
from geonode.layers.models import Layer
from geonode.base.models import TopicCategory
owner = kwargs.get('owner')
if owner and not isinstance(owner, Profile):
kwargs['owner'] = Profile.objects.get(username=owner)
store = kwargs.get("store")
name = kwargs.get("filter")
geonode_layer = "{0}:{1}".format(store, name)
logger.info("Updating geonode layer {0}".format(geonode_layer))
if acquire_lock(get_lock_id(geonode_layer), 30):
output = gs_slurp(**kwargs)
if output:
layer = Layer.objects.get(store=store, name=name)
layer.constraints_other_en = getattr(
settings, "FULCRUM_GEONODE_RESTRICTIONS")
layer.category = TopicCategory.objects.get(
gn_description=getattr(settings, "FULCRUM_CATEGORY_NAME"))
layer.save()
else:
logger.error("Called update_geonode_layers twice for the same layer.")
def update_geonode_layers(**kwargs):
"""
Runs update layers.
"""
from geonode.geoserver.helpers import gs_slurp
from geonode.people.models import Profile
from geonode.layers.models import Layer
from geonode.base.models import TopicCategory
owner = kwargs.get('owner')
if owner and not isinstance(owner, Profile):
kwargs['owner'] = Profile.objects.get(username=owner)
store = kwargs.get("store")
name = kwargs.get("filter")
geonode_layer = "{0}:{1}".format(store, name)
logger.info("Updating geonode layer {0}".format(geonode_layer))
if acquire_lock(get_lock_id(geonode_layer), 30):
output = gs_slurp(**kwargs)
if output:
layer = Layer.objects.get(store=store, name=name)
layer.constraints_other_en = getattr(settings, "FULCRUM_GEONODE_RESTRICTIONS")
layer.category = TopicCategory.objects.get(gn_description=getattr(settings, "FULCRUM_CATEGORY_NAME"))
layer.save()
else:
logger.error("Called update_geonode_layers twice for the same layer.")
def handle(self, layer, layer_config, *args, **kwargs):
"""
Adds a layer in GeoNode, after it has been added to Geoserver.
Handler specific params:
"layer_owner": Sets the owner of the layer.
"""
owner = layer_config.get('layer_owner')
if isinstance(owner, str) or isinstance(owner, unicode):
owner = User.objects.filter(username=owner).first()
if layer_config.get('raster'):
store_name = os.path.splitext(os.path.basename(layer))[0]
filter = None
else:
store_name = self.store_name
filter = layer
results = gs_slurp(workspace=self.workspace,
store=store_name,
filter=filter,
owner=owner,
permissions=layer_config.get('permissions'))
if self.importer.upload_file and results['layers'][0][
'status'] == 'created':
matched_layer = Layer.objects.get(
name=results['layers'][0]['name'])
upload_layer = UploadLayer.objects.get(
upload=self.importer.upload_file.upload,
index=layer_config.get('index'))
upload_layer.layer = matched_layer
upload_layer.save()
return results
def handle(self, **options):
ignore_errors = options.get('ignore_errors')
skip_unadvertised = options.get('skip_unadvertised')
remove_deleted = options.get('remove_deleted')
verbosity = int(options.get('verbosity'))
user = options.get('user')
owner = get_valid_user(user)
workspace = options.get('workspace')
filter = options.get('filter')
store = options.get('store')
if verbosity > 0:
console = sys.stdout
else:
console = None
output = gs_slurp(
ignore_errors,
verbosity=verbosity,
owner=owner,
console=console,
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
remove_deleted=remove_deleted)
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output['layers']:
if dict_['status'] == 'failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if remove_deleted:
print "Detailed report of layers to be deleted from GeoNode that failed:"
for dict_ in output['deleted_layers']:
if dict_['status'] == 'delete_failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if verbosity > 0:
print "\n\nFinished processing %d layers in %s seconds.\n" % (
len(output['layers']), round(output['stats']['duration_sec'], 2))
print "%d Created layers" % output['stats']['created']
print "%d Updated layers" % output['stats']['updated']
print "%d Failed layers" % output['stats']['failed']
try:
duration_layer = round(
output['stats']['duration_sec'] * 1.0 / len(output['layers']), 2)
except ZeroDivisionError:
duration_layer = 0
if len(output) > 0:
print "%f seconds per layer" % duration_layer
if remove_deleted:
print "\n%d Deleted layers" % output['stats']['deleted']
def handle(self, **options):
ignore_errors = options.get('ignore_errors')
skip_unadvertised = options.get('skip_unadvertised')
remove_deleted = options.get('remove_deleted')
verbosity = int(options.get('verbosity'))
user = options.get('user')
owner = get_valid_user(user)
workspace = options.get('workspace')
filter = options.get('filter')
store = options.get('store')
if verbosity > 0:
console = sys.stdout
else:
console = None
output = gs_slurp(ignore_errors,
verbosity=verbosity,
owner=owner,
console=console,
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
remove_deleted=remove_deleted)
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output['layers']:
if dict_['status'] == 'failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if remove_deleted:
print "Detailed report of layers to be deleted from GeoNode that failed:"
for dict_ in output['deleted_layers']:
if dict_['status'] == 'delete_failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if verbosity > 0:
print "\n\nFinished processing %d layers in %s seconds.\n" % (len(
output['layers']), round(output['stats']['duration_sec'], 2))
print "%d Created layers" % output['stats']['created']
print "%d Updated layers" % output['stats']['updated']
print "%d Failed layers" % output['stats']['failed']
try:
duration_layer = round(
output['stats']['duration_sec'] * 1.0 /
len(output['layers']), 2)
except ZeroDivisionError:
duration_layer = 0
if len(output) > 0:
print "%f seconds per layer" % duration_layer
if remove_deleted:
print "\n%d Deleted layers" % output['stats']['deleted']
def layer_create(request, data=None, template='upload/layer_create.html'):
print 'layer create'
if request.method == 'POST':
feature_type = json.loads(request.POST.get(u'featureType', None))
datastore = feature_type['store']['name']
store_create_geogig = json.loads(request.POST.get(u'storeCreateGeogig', 'false'))
if store_create_geogig:
if not feature_type['store']['name']:
store_proposed = slugify(' '.join([request.user.username, feature_type['name']]))
store_created = create_geoserver_db_featurestore(store_type='geogig', store_name=store_proposed)
feature_type['store']['name'] = store_created.name
# -- only allow creation of layers in the whitelisted datastores
try:
settings.ALLOWED_DATASTORE_LAYER_CREATE
except AttributeError:
return HttpResponse(status=FORBIDDEN, content='ALLOWED_DATASTORE_LAYER_CREATE whitelist is not defined.')
if datastore not in settings.ALLOWED_DATASTORE_LAYER_CREATE:
return HttpResponse(status=FORBIDDEN, content='datastore specified in featureType is not in the ALLOWED_DATASTORE_LAYER_CREATE whitelist.')
post_request = requests.post(
'{}/workspaces/{}/datastores/{}/featuretypes.json'.format(ogc_server_settings.rest, feature_type['namespace']['name'], datastore),
data='{{"featureType":{}}}'.format(json.dumps(feature_type)),
auth=ogc_server_settings.credentials,
headers={'content-type': 'application/json'}
)
if post_request.status_code == 200 or post_request.status_code == 201:
# import the layer from geoserver to geonode
response = gs_slurp(filter=feature_type['name'], workspace=feature_type['namespace']['name'], store=feature_type['store']['name'])
if 'layers' in response and len(response['layers']) == 1 and 'name' in response['layers'][0] and response['layers'][0]['name'] == feature_type['name']:
# configruer layer with time dimension as a list for now. Since importer is being refactored,
# we'll change how it is done.
layer = gs_catalog.get_layer(feature_type['name'])
resource = layer.resource
if layer:
time_info = DimensionInfo(
name='time',
enabled=True,
presentation='LIST',
resolution=None,
units=None,
unitSymbol=None,
attribute='time',
end_attribute=None,
strategy=None)
resource.metadata = {'time': time_info}
resource.catalog.save(resource)
return HttpResponse(status=post_request.status_code, content=post_request.text)
return HttpResponse(status=500, content='failed to configure layer')
else:
return HttpResponse(status=500, content='failed to add created layer from geoserver to geonode')
else:
return HttpResponse(status=post_request.status_code, content=post_request.text)
print '---- create layer response: ', post_request.text
return render_to_response(template, RequestContext(request, {}))
def handle(self, layer, layer_config, *args, **kwargs):
"""
Adds a layer in GeoNode, after it has been added to Geoserver.
Handler specific params:
"layer_owner": Sets the owner of the layer.
"""
return gs_slurp(workspace=self.workspace,
store=self.store_name,
filter=layer,
owner=layer_config.get('layer_owner'))
def handle(self, layer, layer_config, *args, **kwargs):
"""
Adds a layer in GeoNode, after it has been added to Geoserver.
Handler specific params:
"layer_owner": Sets the owner of the layer.
"""
return gs_slurp(workspace=self.workspace,
store=self.store_name,
filter=layer,
owner=layer_config.get('layer_owner'))
def handle(self, **options):
ignore_errors = options.get('ignore_errors')
verbosity = int(options.get('verbosity'))
user = options.get('user')
owner = get_valid_user(user)
workspace = options.get('workspace')
filter = options.get('filter')
store = options.get('store')
if verbosity > 0:
console = sys.stdout
else:
console = None
start = datetime.datetime.now()
output = gs_slurp(ignore_errors,
verbosity=verbosity,
owner=owner,
console=console,
workspace=workspace,
store=store,
filter=filter)
updated = [
dict_['name'] for dict_ in output if dict_['status'] == 'updated'
]
created = [
dict_['name'] for dict_ in output if dict_['status'] == 'created'
]
failed = [
dict_['name'] for dict_ in output if dict_['status'] == 'failed'
]
finish = datetime.datetime.now()
td = finish - start
duration = td.microseconds / 1000000 + td.seconds + td.days * 24 * 3600
duration_rounded = round(duration, 2)
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output:
if dict_['status'] == 'failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if verbosity > 0:
print "\n\nFinished processing %d layers in %s seconds.\n" % (
len(output), duration_rounded)
print "%d Created layers" % len(created)
print "%d Updated layers" % len(updated)
print "%d Failed layers" % len(failed)
if len(output) > 0:
print "%f seconds per layer" % (duration * 1.0 / len(output))
def update_geonode_layers(**kwargs):
"""
Runs update layers.
"""
from geonode.geoserver.helpers import gs_slurp
from geonode.people.models import Profile
owner = kwargs.get('owner')
if owner and not isinstance(owner, Profile):
kwargs['owner'] = Profile.objects.get(username=owner)
return gs_slurp(**kwargs)
def task_sync_geoserver(workspace_name, username):
# construct management command arguments
out = StringIO()
User = get_user_model()
user = User.objects.get(username=username)
try:
result = gs_slurp(ignore_errors=False,
verbosity=1,
owner=user,
console=out,
workspace=workspace_name,
store=None,
filter=None,
skip_unadvertised=True,
skip_geonode_registered=True,
remove_deleted=True,
permissions={'users': {
'AnonymousUser': []
}},
execute_signals=True)
error_message = None
except BaseException as e:
result = None
if hasattr(e, 'message'):
error_message = e.message
else:
error_message = str(e)
# for any layers that represent published topomaps, update their
# featureinfo field
topomap_tasks.add_custom_featureinfo_template_topomap.apply_async()
# Send email to user
from_email = settings.DEFAULT_FROM_EMAIL
to_email = '{} <{}>'.format(username, user.email)
subject = _('[Task Complete] Sync GeoServer')
context = {
'username': username,
'output': out.getvalue(),
'error_message': error_message,
'result': result
}
text_content = render_to_string('email/task_complete.txt', context=context)
html_content = render_to_string('email/task_complete.html',
context=context)
send_mail(subject,
text_content,
from_email, [to_email],
html_message=html_content)
return True
def handle(self, **options):
ignore_errors = options.get('ignore_errors')
verbosity = int(options.get('verbosity'))
user = options.get('user')
owner = get_valid_user(user)
workspace = options.get('workspace')
filter = options.get('filter')
store = options.get('store')
if verbosity > 0:
console = sys.stdout
else:
console = None
start = datetime.datetime.now()
output = gs_slurp(ignore_errors, verbosity=verbosity,
owner=owner, console=console, workspace=workspace, store=store, filter=filter)
updated = [dict_['name'] for dict_ in output if dict_['status']=='updated']
created = [dict_['name'] for dict_ in output if dict_['status']=='created']
failed = [dict_['name'] for dict_ in output if dict_['status']=='failed']
finish = datetime.datetime.now()
td = finish - start
duration = td.microseconds / 1000000 + td.seconds + td.days * 24 * 3600
duration_rounded = round(duration, 2)
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output:
if dict_['status'] == 'failed':
print "\n\n", dict_['name'], "\n================"
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if verbosity > 0:
print "\n\nFinished processing %d layers in %s seconds.\n" % (
len(output), duration_rounded)
print "%d Created layers" % len(created)
print "%d Updated layers" % len(updated)
print "%d Failed layers" % len(failed)
if len(output) > 0:
print "%f seconds per layer" % (duration * 1.0 / len(output))
def import_file(self, in_file, configuration_options=[]):
"""
Imports the file.
"""
self.assertTrue(os.path.exists(in_file))
# run ogr2ogr
gi = GDALImport(in_file)
layers = gi.handle(configuration_options=configuration_options)
d = db.connections['datastore'].settings_dict
connection_string = "PG:dbname='%s' user='******' password='******'" % (d['NAME'], d['USER'], d['PASSWORD'])
output = []
for layer, layer_config in layers:
# expose the featureType in geoserver
self.cat.publish_featuretype(layer, self.datastore, 'EPSG:4326')
output.append(gs_slurp(workspace='geonode', store=self.datastore.name, filter=layer))
return output
def handle(self, **options):
ignore_errors = options.get("ignore_errors")
verbosity = int(options.get("verbosity"))
user = options.get("user")
owner = get_valid_user(user)
workspace = options.get("workspace")
if verbosity > 0:
console = sys.stdout
else:
console = None
start = datetime.datetime.now()
output = gs_slurp(ignore_errors, verbosity=verbosity, owner=owner, console=console, workspace=workspace)
updated = [dict_["name"] for dict_ in output if dict_["status"] == "updated"]
created = [dict_["name"] for dict_ in output if dict_["status"] == "created"]
failed = [dict_["name"] for dict_ in output if dict_["status"] == "failed"]
finish = datetime.datetime.now()
td = finish - start
duration = td.microseconds / 1000000 + td.seconds + td.days * 24 * 3600
duration_rounded = round(duration, 2)
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output:
if dict_["status"] == "failed":
print "\n\n", dict_["name"], "\n================"
traceback.print_exception(dict_["exception_type"], dict_["error"], dict_["traceback"])
if verbosity > 0:
print "\n\nFinished processing %d layers in %s seconds.\n" % (len(output), duration_rounded)
print "%d Created layers" % len(created)
print "%d Updated layers" % len(updated)
print "%d Failed layers" % len(failed)
if len(output) > 0:
print "%f seconds per layer" % (duration * 1.0 / len(output))
def geoserver_update_layers(*args, **kwargs):
"""
Runs update layers.
"""
return gs_slurp(*args, **kwargs)
def test_layer_permissions(self):
try:
# Test permissions on a layer
# grab bobby
bobby = get_user_model().objects.get(username="******")
layers = Layer.objects.all()[:2].values_list('id', flat=True)
test_perm_layer = Layer.objects.get(id=layers[0])
thefile = os.path.join(gisdata.VECTOR_DATA,
'san_andres_y_providencia_poi.shp')
layer = geoserver_upload(test_perm_layer,
thefile,
bobby,
'san_andres_y_providencia_poi',
overwrite=True)
self.assertIsNotNone(layer)
_log(
" ------------------------------------------------------------- "
)
_log(layer)
_log(
" ------------------------------------------------------------- "
)
# Reset GeoFence Rules
purge_geofence_all()
geofence_rules_count = get_geofence_rules_count()
self.assertTrue(geofence_rules_count == 0)
ignore_errors = False
skip_unadvertised = False
skip_geonode_registered = False
remove_deleted = True
verbosity = 2
owner = get_valid_user('admin')
workspace = 'geonode'
filter = None
store = None
permissions = {'users': {"admin": ['change_layer_data']}}
gs_slurp(ignore_errors,
verbosity=verbosity,
owner=owner,
console=StreamToLogger(logger, logging.INFO),
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
skip_geonode_registered=skip_geonode_registered,
remove_deleted=remove_deleted,
permissions=permissions,
execute_signals=True)
layer = Layer.objects.get(title='san_andres_y_providencia_poi')
check_layer(layer)
geofence_rules_count = get_geofence_rules_count()
_log("0. geofence_rules_count: %s " % geofence_rules_count)
self.assertEquals(geofence_rules_count, 2)
# Set the layer private for not authenticated users
layer.set_permissions({'users': {'AnonymousUser': []}})
url = 'http://localhost:8080/geoserver/geonode/ows?' \
'LAYERS=geonode%3Asan_andres_y_providencia_poi&STYLES=' \
'&FORMAT=image%2Fpng&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap' \
'&SRS=EPSG%3A4326' \
'&BBOX=-81.394599749999,13.316009005566,' \
'-81.370560451855,13.372728455566' \
'&WIDTH=217&HEIGHT=512'
# test view_resourcebase permission on anonymous user
request = urllib2.Request(url)
response = urllib2.urlopen(request)
self.assertTrue(response.info().getheader('Content-Type'),
'application/vnd.ogc.se_xml;charset=UTF-8')
# test WMS with authenticated user that has not view_resourcebase:
# the layer must be not accessible (response is xml)
request = urllib2.Request(url)
base64string = base64.encodestring(
'%s:%s' % ('bobby', 'bob')).replace('\n', '')
request.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(request)
self.assertTrue(response.info().getheader('Content-Type'),
'application/vnd.ogc.se_xml;charset=UTF-8')
# test WMS with authenticated user that has view_resourcebase: the layer
# must be accessible (response is image)
assign_perm('view_resourcebase', bobby, layer.get_self_resource())
request = urllib2.Request(url)
base64string = base64.encodestring(
'%s:%s' % ('bobby', 'bob')).replace('\n', '')
request.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(request)
self.assertTrue(response.info().getheader('Content-Type'),
'image/png')
# test change_layer_data
# would be nice to make a WFS/T request and test results, but this
# would work only on PostGIS layers
# test change_layer_style
url = 'http://localhost:8000/gs/rest/workspaces/geonode/styles/san_andres_y_providencia_poi.xml'
sld = """<?xml version="1.0" encoding="UTF-8"?>
<sld:StyledLayerDescriptor xmlns:sld="http://www.opengis.net/sld"
xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.0.0"
xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd">
<sld:NamedLayer>
<sld:Name>geonode:san_andres_y_providencia_poi</sld:Name>
<sld:UserStyle>
<sld:Name>san_andres_y_providencia_poi</sld:Name>
<sld:Title>san_andres_y_providencia_poi</sld:Title>
<sld:IsDefault>1</sld:IsDefault>
<sld:FeatureTypeStyle>
<sld:Rule>
<sld:PointSymbolizer>
<sld:Graphic>
<sld:Mark>
<sld:Fill>
<sld:CssParameter name="fill">#8A7700
</sld:CssParameter>
</sld:Fill>
<sld:Stroke>
<sld:CssParameter name="stroke">#bbffff
</sld:CssParameter>
</sld:Stroke>
</sld:Mark>
<sld:Size>10</sld:Size>
</sld:Graphic>
</sld:PointSymbolizer>
</sld:Rule>
</sld:FeatureTypeStyle>
</sld:UserStyle>
</sld:NamedLayer>
</sld:StyledLayerDescriptor>"""
# user without change_layer_style cannot edit it
self.assertTrue(self.client.login(username='******',
password='******'))
response = self.client.put(
url, sld, content_type='application/vnd.ogc.sld+xml')
self.assertEquals(response.status_code, 401)
# user with change_layer_style can edit it
assign_perm('change_layer_style', bobby, layer)
perm_spec = {
'users': {
'bobby': [
'view_resourcebase',
'change_resourcebase',
]
}
}
layer.set_permissions(perm_spec)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
response = self.client.put(
url, sld, content_type='application/vnd.ogc.sld+xml')
finally:
try:
layer.delete()
except BaseException:
pass
def handle(self, **options):
ignore_errors = options.get('ignore_errors')
skip_unadvertised = options.get('skip_unadvertised')
skip_geonode_registered = options.get('skip_geonode_registered')
remove_deleted = options.get('remove_deleted')
verbosity = int(options.get('verbosity'))
user = options.get('user')
owner = get_valid_user(user)
workspace = options.get('workspace')
filter = options.get('filter')
store = options.get('store')
if not options.get('permissions'):
permissions = None
else:
permissions = ast.literal_eval(options.get('permissions'))
if verbosity > 0:
console = sys.stdout
else:
console = None
output = gs_slurp(
ignore_errors,
verbosity=verbosity,
owner=owner,
console=console,
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
skip_geonode_registered=skip_geonode_registered,
remove_deleted=remove_deleted,
permissions=permissions,
execute_signals=True)
if verbosity > 1:
print("\nDetailed report of failures:")
for dict_ in output['layers']:
if dict_['status'] == 'failed':
print("\n\n", dict_['name'], "\n================")
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if remove_deleted:
print("Detailed report of layers to be deleted from GeoNode that failed:")
for dict_ in output['deleted_layers']:
if dict_['status'] == 'delete_failed':
print("\n\n", dict_['name'], "\n================")
traceback.print_exception(dict_['exception_type'],
dict_['error'],
dict_['traceback'])
if verbosity > 0:
print("\n\nFinished processing {} layers in {} seconds.\n".format(
len(output['layers']), round(output['stats']['duration_sec'], 2)))
print("{} Created layers".format(output['stats']['created']))
print("{} Updated layers".format(output['stats']['updated']))
print("{} Failed layers".format(output['stats']['failed']))
try:
duration_layer = round(
output['stats']['duration_sec'] * 1.0 / len(output['layers']), 2)
except ZeroDivisionError:
duration_layer = 0
if len(output) > 0:
print("{} seconds per layer".format(duration_layer))
if remove_deleted:
print("\n{} Deleted layers".format(output['stats']['deleted']))
def test_layer_permissions(self):
try:
# Test permissions on a layer
# grab bobby
bobby = get_user_model().objects.get(username="******")
layers = Layer.objects.all()[:2].values_list('id', flat=True)
test_perm_layer = Layer.objects.get(id=layers[0])
thefile = os.path.join(
gisdata.VECTOR_DATA,
'san_andres_y_providencia_poi.shp')
layer = geoserver_upload(
test_perm_layer,
thefile,
bobby,
'san_andres_y_providencia_poi',
overwrite=True
)
self.assertIsNotNone(layer)
# Reset GeoFence Rules
purge_geofence_all()
geofence_rules_count = get_geofence_rules_count()
self.assertTrue(geofence_rules_count == 0)
ignore_errors = False
skip_unadvertised = False
skip_geonode_registered = False
remove_deleted = True
verbosity = 2
owner = get_valid_user('admin')
workspace = 'geonode'
filter = None
store = None
permissions = {'users': {"admin": ['change_layer_data']}}
gs_slurp(
ignore_errors,
verbosity=verbosity,
owner=owner,
console=StreamToLogger(logger, logging.INFO),
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
skip_geonode_registered=skip_geonode_registered,
remove_deleted=remove_deleted,
permissions=permissions,
execute_signals=True)
layer = Layer.objects.get(title='san_andres_y_providencia_poi')
check_layer(layer)
geofence_rules_count = get_geofence_rules_count()
_log("0. geofence_rules_count: %s " % geofence_rules_count)
self.assertEquals(geofence_rules_count, 2)
# Set the layer private for not authenticated users
layer.set_permissions({'users': {'AnonymousUser': []}})
url = 'http://localhost:8080/geoserver/geonode/ows?' \
'LAYERS=geonode%3Asan_andres_y_providencia_poi&STYLES=' \
'&FORMAT=image%2Fpng&SERVICE=WMS&VERSION=1.1.1&REQUEST=GetMap' \
'&SRS=EPSG%3A4326' \
'&BBOX=-81.394599749999,13.316009005566,' \
'-81.370560451855,13.372728455566' \
'&WIDTH=217&HEIGHT=512'
# test view_resourcebase permission on anonymous user
request = urllib2.Request(url)
response = urllib2.urlopen(request)
self.assertTrue(
response.info().getheader('Content-Type'),
'application/vnd.ogc.se_xml;charset=UTF-8'
)
# test WMS with authenticated user that has not view_resourcebase:
# the layer must be not accessible (response is xml)
request = urllib2.Request(url)
base64string = base64.encodestring(
'%s:%s' % ('bobby', 'bob')).replace('\n', '')
request.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(request)
self.assertTrue(
response.info().getheader('Content-Type'),
'application/vnd.ogc.se_xml;charset=UTF-8'
)
# test WMS with authenticated user that has view_resourcebase: the layer
# must be accessible (response is image)
assign_perm('view_resourcebase', bobby, layer.get_self_resource())
request = urllib2.Request(url)
base64string = base64.encodestring(
'%s:%s' % ('bobby', 'bob')).replace('\n', '')
request.add_header("Authorization", "Basic %s" % base64string)
response = urllib2.urlopen(request)
self.assertTrue(response.info().getheader('Content-Type'), 'image/png')
# test change_layer_data
# would be nice to make a WFS/T request and test results, but this
# would work only on PostGIS layers
# test change_layer_style
url = 'http://localhost:8000/gs/rest/workspaces/geonode/styles/san_andres_y_providencia_poi.xml'
sld = """<?xml version="1.0" encoding="UTF-8"?>
<sld:StyledLayerDescriptor xmlns:sld="http://www.opengis.net/sld"
xmlns:gml="http://www.opengis.net/gml" xmlns:ogc="http://www.opengis.net/ogc"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" version="1.0.0"
xsi:schemaLocation="http://www.opengis.net/sld http://schemas.opengis.net/sld/1.0.0/StyledLayerDescriptor.xsd">
<sld:NamedLayer>
<sld:Name>geonode:san_andres_y_providencia_poi</sld:Name>
<sld:UserStyle>
<sld:Name>san_andres_y_providencia_poi</sld:Name>
<sld:Title>san_andres_y_providencia_poi</sld:Title>
<sld:IsDefault>1</sld:IsDefault>
<sld:FeatureTypeStyle>
<sld:Rule>
<sld:PointSymbolizer>
<sld:Graphic>
<sld:Mark>
<sld:Fill>
<sld:CssParameter name="fill">#8A7700
</sld:CssParameter>
</sld:Fill>
<sld:Stroke>
<sld:CssParameter name="stroke">#bbffff
</sld:CssParameter>
</sld:Stroke>
</sld:Mark>
<sld:Size>10</sld:Size>
</sld:Graphic>
</sld:PointSymbolizer>
</sld:Rule>
</sld:FeatureTypeStyle>
</sld:UserStyle>
</sld:NamedLayer>
</sld:StyledLayerDescriptor>"""
# user without change_layer_style cannot edit it
self.assertTrue(self.client.login(username='******', password='******'))
response = self.client.put(url, sld, content_type='application/vnd.ogc.sld+xml')
self.assertEquals(response.status_code, 401)
# user with change_layer_style can edit it
assign_perm('change_layer_style', bobby, layer)
perm_spec = {
'users': {
'bobby': ['view_resourcebase',
'change_resourcebase', ]
}
}
layer.set_permissions(perm_spec)
response = self.client.get(url)
self.assertEquals(response.status_code, 200)
response = self.client.put(url, sld, content_type='application/vnd.ogc.sld+xml')
finally:
try:
layer.delete()
except BaseException:
pass
def test_layer_upload_with_time(self):
""" Try uploading a layer and verify that the user can administrate
his own layer despite not being a site administrator.
"""
try:
# user without change_layer_style cannot edit it
self.assertTrue(self.client.login(username='******',
password='******'))
# grab bobby
bobby = get_user_model().objects.get(username="******")
anonymous_group, created = Group.objects.get_or_create(
name='anonymous')
# Upload to GeoServer
saved_layer = geoserver_upload(Layer(),
os.path.join(
gisdata.GOOD_DATA, 'time/'
"boxes_with_date.shp"),
bobby,
'boxes_with_date_by_bobby',
overwrite=True)
# Test that layer owner can wipe GWC Cache
ignore_errors = False
skip_unadvertised = False
skip_geonode_registered = False
remove_deleted = True
verbosity = 2
owner = bobby
workspace = 'geonode'
filter = None
store = None
permissions = {
'users': {
"bobby": ['view_resourcebase', 'change_layer_data']
},
'groups': {
anonymous_group: ['view_resourcebase']
},
}
gs_slurp(ignore_errors,
verbosity=verbosity,
owner=owner,
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
skip_geonode_registered=skip_geonode_registered,
remove_deleted=remove_deleted,
permissions=permissions,
execute_signals=True)
saved_layer = Layer.objects.get(title='boxes_with_date_by_bobby')
check_layer(saved_layer)
from lxml import etree
from geonode.geoserver.helpers import get_store
from geonode.geoserver.signals import gs_catalog
self.assertIsNotNone(saved_layer)
workspace, name = saved_layer.alternate.split(':')
self.assertIsNotNone(workspace)
self.assertIsNotNone(name)
ws = gs_catalog.get_workspace(workspace)
self.assertIsNotNone(ws)
store = get_store(gs_catalog, saved_layer.store, workspace=ws)
self.assertIsNotNone(store)
url = settings.OGC_SERVER['default']['LOCATION']
user = settings.OGC_SERVER['default']['USER']
passwd = settings.OGC_SERVER['default']['PASSWORD']
rest_path = 'rest/workspaces/geonode/datastores/{lyr_name}/featuretypes/{lyr_name}.xml'.\
format(lyr_name=name)
import requests
from requests.auth import HTTPBasicAuth
r = requests.get(url + rest_path, auth=HTTPBasicAuth(user, passwd))
self.assertEquals(r.status_code, 200)
_log(r.text)
featureType = etree.ElementTree(etree.fromstring(r.text))
metadata = featureType.findall('./[metadata]')
self.assertEquals(len(metadata), 0)
payload = """<featureType>
<metadata>
<entry key="elevation">
<dimensionInfo>
<enabled>false</enabled>
</dimensionInfo>
</entry>
<entry key="time">
<dimensionInfo>
<enabled>true</enabled>
<attribute>date</attribute>
<presentation>LIST</presentation>
<units>ISO8601</units>
<defaultValue/>
<nearestMatchEnabled>false</nearestMatchEnabled>
</dimensionInfo>
</entry>
</metadata></featureType>"""
r = requests.put(url + rest_path,
data=payload,
headers={'Content-type': 'application/xml'},
auth=HTTPBasicAuth(user, passwd))
self.assertEquals(r.status_code, 200)
r = requests.get(url + rest_path, auth=HTTPBasicAuth(user, passwd))
self.assertEquals(r.status_code, 200)
_log(r.text)
featureType = etree.ElementTree(etree.fromstring(r.text))
metadata = featureType.findall('./[metadata]')
_log(etree.tostring(metadata[0], encoding='utf8', method='xml'))
self.assertEquals(len(metadata), 1)
saved_layer.set_default_permissions()
from geonode.geoserver.views import get_layer_capabilities
capab = get_layer_capabilities(saved_layer, tolerant=True)
self.assertIsNotNone(capab)
wms_capabilities_url = reverse('capabilities_layer',
args=[saved_layer.id])
wms_capabilities_resp = self.client.get(wms_capabilities_url)
self.assertTrue(wms_capabilities_resp.status_code, 200)
all_times = None
if wms_capabilities_resp.status_code >= 200 and wms_capabilities_resp.status_code < 400:
wms_capabilities = wms_capabilities_resp.getvalue()
if wms_capabilities:
namespaces = {
'wms': 'http://www.opengis.net/wms',
'xlink': 'http://www.w3.org/1999/xlink',
'xsi': 'http://www.w3.org/2001/XMLSchema-instance'
}
e = etree.fromstring(wms_capabilities)
for atype in e.findall(
"./[wms:Name='%s']/wms:Dimension[@name='time']" %
(saved_layer.alternate), namespaces):
dim_name = atype.get('name')
if dim_name:
dim_name = str(dim_name).lower()
if dim_name == 'time':
dim_values = atype.text
if dim_values:
all_times = dim_values.split(",")
break
self.assertIsNotNone(all_times)
self.assertEquals(all_times, [
'2000-03-01T00:00:00.000Z', '2000-03-02T00:00:00.000Z',
'2000-03-03T00:00:00.000Z', '2000-03-04T00:00:00.000Z',
'2000-03-05T00:00:00.000Z', '2000-03-06T00:00:00.000Z',
'2000-03-07T00:00:00.000Z', '2000-03-08T00:00:00.000Z',
'2000-03-09T00:00:00.000Z', '2000-03-10T00:00:00.000Z',
'2000-03-11T00:00:00.000Z', '2000-03-12T00:00:00.000Z',
'2000-03-13T00:00:00.000Z', '2000-03-14T00:00:00.000Z',
'2000-03-15T00:00:00.000Z', '2000-03-16T00:00:00.000Z',
'2000-03-17T00:00:00.000Z', '2000-03-18T00:00:00.000Z',
'2000-03-19T00:00:00.000Z', '2000-03-20T00:00:00.000Z',
'2000-03-21T00:00:00.000Z', '2000-03-22T00:00:00.000Z',
'2000-03-23T00:00:00.000Z', '2000-03-24T00:00:00.000Z',
'2000-03-25T00:00:00.000Z', '2000-03-26T00:00:00.000Z',
'2000-03-27T00:00:00.000Z', '2000-03-28T00:00:00.000Z',
'2000-03-29T00:00:00.000Z', '2000-03-30T00:00:00.000Z',
'2000-03-31T00:00:00.000Z', '2000-04-01T00:00:00.000Z',
'2000-04-02T00:00:00.000Z', '2000-04-03T00:00:00.000Z',
'2000-04-04T00:00:00.000Z', '2000-04-05T00:00:00.000Z',
'2000-04-06T00:00:00.000Z', '2000-04-07T00:00:00.000Z',
'2000-04-08T00:00:00.000Z', '2000-04-09T00:00:00.000Z',
'2000-04-10T00:00:00.000Z', '2000-04-11T00:00:00.000Z',
'2000-04-12T00:00:00.000Z', '2000-04-13T00:00:00.000Z',
'2000-04-14T00:00:00.000Z', '2000-04-15T00:00:00.000Z',
'2000-04-16T00:00:00.000Z', '2000-04-17T00:00:00.000Z',
'2000-04-18T00:00:00.000Z', '2000-04-19T00:00:00.000Z',
'2000-04-20T00:00:00.000Z', '2000-04-21T00:00:00.000Z',
'2000-04-22T00:00:00.000Z', '2000-04-23T00:00:00.000Z',
'2000-04-24T00:00:00.000Z', '2000-04-25T00:00:00.000Z',
'2000-04-26T00:00:00.000Z', '2000-04-27T00:00:00.000Z',
'2000-04-28T00:00:00.000Z', '2000-04-29T00:00:00.000Z',
'2000-04-30T00:00:00.000Z', '2000-05-01T00:00:00.000Z',
'2000-05-02T00:00:00.000Z', '2000-05-03T00:00:00.000Z',
'2000-05-04T00:00:00.000Z', '2000-05-05T00:00:00.000Z',
'2000-05-06T00:00:00.000Z', '2000-05-07T00:00:00.000Z',
'2000-05-08T00:00:00.000Z', '2000-05-09T00:00:00.000Z',
'2000-05-10T00:00:00.000Z', '2000-05-11T00:00:00.000Z',
'2000-05-12T00:00:00.000Z', '2000-05-13T00:00:00.000Z',
'2000-05-14T00:00:00.000Z', '2000-05-15T00:00:00.000Z',
'2000-05-16T00:00:00.000Z', '2000-05-17T00:00:00.000Z',
'2000-05-18T00:00:00.000Z', '2000-05-19T00:00:00.000Z',
'2000-05-20T00:00:00.000Z', '2000-05-21T00:00:00.000Z',
'2000-05-22T00:00:00.000Z', '2000-05-23T00:00:00.000Z',
'2000-05-24T00:00:00.000Z', '2000-05-25T00:00:00.000Z',
'2000-05-26T00:00:00.000Z', '2000-05-27T00:00:00.000Z',
'2000-05-28T00:00:00.000Z', '2000-05-29T00:00:00.000Z',
'2000-05-30T00:00:00.000Z', '2000-05-31T00:00:00.000Z',
'2000-06-01T00:00:00.000Z', '2000-06-02T00:00:00.000Z',
'2000-06-03T00:00:00.000Z', '2000-06-04T00:00:00.000Z',
'2000-06-05T00:00:00.000Z', '2000-06-06T00:00:00.000Z',
'2000-06-07T00:00:00.000Z', '2000-06-08T00:00:00.000Z'
])
saved_layer.set_default_permissions()
url = reverse('layer_metadata',
args=[saved_layer.service_typename])
resp = self.client.get(url)
self.assertEquals(resp.status_code, 200)
finally:
# Clean up and completely delete the layer
try:
saved_layer.delete()
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.helpers import cleanup
cleanup(saved_layer.name, saved_layer.uuid)
except BaseException:
pass
>>>>>>> e7605f5980062789a1dfe0321b74882a9af32ed6
=======
>>>>>>> 2c522ce5efd5757f4d94e63a543e24e9ac97805b
if verbosity > 0:
console = sys.stdout
else:
console = None
output = gs_slurp(
ignore_errors,
verbosity=verbosity,
owner=owner,
console=console,
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
skip_geonode_registered=skip_geonode_registered,
remove_deleted=remove_deleted,
<<<<<<< HEAD
permissions=permissions,
execute_signals=True)
=======
permissions=permissions)
>>>>>>> 2c522ce5efd5757f4d94e63a543e24e9ac97805b
if verbosity > 1:
print "\nDetailed report of failures:"
for dict_ in output['layers']:
def layer_create(request, data=None, template='upload/layer_create.html'):
print 'layer create'
if request.method == 'POST':
feature_type = json.loads(request.POST.get(u'featureType', None))
datastore = feature_type['store']['name']
store_create_geogig = json.loads(
request.POST.get(u'storeCreateGeogig', 'false'))
if store_create_geogig:
if not feature_type['store']['name']:
store_proposed = slugify(' '.join(
[request.user.username, feature_type['name']]))
store_created = create_geoserver_db_featurestore(
store_type='geogig', store_name=store_proposed)
feature_type['store']['name'] = store_created.name
# -- only allow creation of layers in the whitelisted datastores
try:
settings.ALLOWED_DATASTORE_LAYER_CREATE
except AttributeError:
return HttpResponse(
status=FORBIDDEN,
content=
'ALLOWED_DATASTORE_LAYER_CREATE whitelist is not defined.')
if datastore not in settings.ALLOWED_DATASTORE_LAYER_CREATE:
return HttpResponse(
status=FORBIDDEN,
content=
'datastore specified in featureType is not in the ALLOWED_DATASTORE_LAYER_CREATE whitelist.'
)
post_request = requests.post(
'{}/workspaces/{}/datastores/{}/featuretypes.json'.format(
ogc_server_settings.rest, feature_type['namespace']['name'],
datastore),
data='{{"featureType":{}}}'.format(json.dumps(feature_type)),
auth=ogc_server_settings.credentials,
headers={'content-type': 'application/json'})
if post_request.status_code == 200 or post_request.status_code == 201:
# import the layer from geoserver to geonode
response = gs_slurp(filter=feature_type['name'],
workspace=feature_type['namespace']['name'],
store=feature_type['store']['name'])
if 'layers' in response and len(
response['layers']
) == 1 and 'name' in response['layers'][0] and response['layers'][
0]['name'] == feature_type['name']:
# configruer layer with time dimension as a list for now. Since importer is being refactored,
# we'll change how it is done.
layer = gs_catalog.get_layer(feature_type['name'])
resource = layer.resource
if layer:
time_info = DimensionInfo(name='time',
enabled=True,
presentation='LIST',
resolution=None,
units=None,
unitSymbol=None,
attribute='time',
end_attribute=None,
strategy=None)
resource.metadata = {'time': time_info}
resource.catalog.save(resource)
return HttpResponse(status=post_request.status_code,
content=post_request.text)
return HttpResponse(status=500,
content='failed to configure layer')
else:
return HttpResponse(
status=500,
content=
'failed to add created layer from geoserver to geonode')
else:
return HttpResponse(status=post_request.status_code,
content=post_request.text)
print '---- create layer response: ', post_request.text
return render_to_response(template, RequestContext(request, {}))
def geoserver_update_layers(*args, **kwargs):
"""
Runs update layers.
"""
return gs_slurp(*args, **kwargs)
def test_layer_upload_with_time(self):
""" Try uploading a layer and verify that the user can administrate
his own layer despite not being a site administrator.
"""
try:
# user without change_layer_style cannot edit it
self.assertTrue(self.client.login(username='******', password='******'))
# grab bobby
bobby = get_user_model().objects.get(username="******")
anonymous_group, created = Group.objects.get_or_create(name='anonymous')
# Upload to GeoServer
saved_layer = geoserver_upload(
Layer(),
os.path.join(
gisdata.GOOD_DATA,
'time/'
"boxes_with_date.shp"),
bobby,
'boxes_with_date_by_bobby',
overwrite=True
)
# Test that layer owner can wipe GWC Cache
ignore_errors = False
skip_unadvertised = False
skip_geonode_registered = False
remove_deleted = True
verbosity = 2
owner = bobby
workspace = 'geonode'
filter = None
store = None
permissions = {
'users': {"bobby": ['view_resourcebase', 'change_layer_data']},
'groups': {anonymous_group: ['view_resourcebase']},
}
gs_slurp(
ignore_errors,
verbosity=verbosity,
owner=owner,
workspace=workspace,
store=store,
filter=filter,
skip_unadvertised=skip_unadvertised,
skip_geonode_registered=skip_geonode_registered,
remove_deleted=remove_deleted,
permissions=permissions,
execute_signals=True)
saved_layer = Layer.objects.get(title='boxes_with_date_by_bobby')
check_layer(saved_layer)
from lxml import etree
from geonode.geoserver.helpers import get_store
from geonode.geoserver.signals import gs_catalog
self.assertIsNotNone(saved_layer)
workspace, name = saved_layer.alternate.split(':')
self.assertIsNotNone(workspace)
self.assertIsNotNone(name)
ws = gs_catalog.get_workspace(workspace)
self.assertIsNotNone(ws)
store = get_store(gs_catalog, saved_layer.store, workspace=ws)
self.assertIsNotNone(store)
url = settings.OGC_SERVER['default']['LOCATION']
user = settings.OGC_SERVER['default']['USER']
passwd = settings.OGC_SERVER['default']['PASSWORD']
rest_path = 'rest/workspaces/geonode/datastores/{lyr_name}/featuretypes/{lyr_name}.xml'.\
format(lyr_name=name)
import requests
from requests.auth import HTTPBasicAuth
r = requests.get(url + rest_path,
auth=HTTPBasicAuth(user, passwd))
self.assertEquals(r.status_code, 200)
_log(r.text)
featureType = etree.ElementTree(etree.fromstring(r.text))
metadata = featureType.findall('./[metadata]')
self.assertEquals(len(metadata), 0)
payload = """<featureType>
<metadata>
<entry key="elevation">
<dimensionInfo>
<enabled>false</enabled>
</dimensionInfo>
</entry>
<entry key="time">
<dimensionInfo>
<enabled>true</enabled>
<attribute>date</attribute>
<presentation>LIST</presentation>
<units>ISO8601</units>
<defaultValue/>
<nearestMatchEnabled>false</nearestMatchEnabled>
</dimensionInfo>
</entry>
</metadata></featureType>"""
r = requests.put(url + rest_path,
data=payload,
headers={
'Content-type': 'application/xml'
},
auth=HTTPBasicAuth(user, passwd))
self.assertEquals(r.status_code, 200)
r = requests.get(url + rest_path,
auth=HTTPBasicAuth(user, passwd))
self.assertEquals(r.status_code, 200)
_log(r.text)
featureType = etree.ElementTree(etree.fromstring(r.text))
metadata = featureType.findall('./[metadata]')
_log(etree.tostring(metadata[0], encoding='utf8', method='xml'))
self.assertEquals(len(metadata), 1)
saved_layer.set_default_permissions()
from geonode.geoserver.views import get_layer_capabilities
capab = get_layer_capabilities(saved_layer, tolerant=True)
self.assertIsNotNone(capab)
wms_capabilities_url = reverse('capabilities_layer', args=[saved_layer.id])
wms_capabilities_resp = self.client.get(wms_capabilities_url)
self.assertTrue(wms_capabilities_resp.status_code, 200)
all_times = None
if wms_capabilities_resp.status_code >= 200 and wms_capabilities_resp.status_code < 400:
wms_capabilities = wms_capabilities_resp.getvalue()
if wms_capabilities:
namespaces = {'wms': 'http://www.opengis.net/wms',
'xlink': 'http://www.w3.org/1999/xlink',
'xsi': 'http://www.w3.org/2001/XMLSchema-instance'}
e = etree.fromstring(wms_capabilities)
for atype in e.findall(
"./[wms:Name='%s']/wms:Dimension[@name='time']" % (saved_layer.alternate), namespaces):
dim_name = atype.get('name')
if dim_name:
dim_name = str(dim_name).lower()
if dim_name == 'time':
dim_values = atype.text
if dim_values:
all_times = dim_values.split(",")
break
self.assertIsNotNone(all_times)
self.assertEquals(all_times,
['2000-03-01T00:00:00.000Z', '2000-03-02T00:00:00.000Z',
'2000-03-03T00:00:00.000Z', '2000-03-04T00:00:00.000Z',
'2000-03-05T00:00:00.000Z', '2000-03-06T00:00:00.000Z',
'2000-03-07T00:00:00.000Z', '2000-03-08T00:00:00.000Z',
'2000-03-09T00:00:00.000Z', '2000-03-10T00:00:00.000Z',
'2000-03-11T00:00:00.000Z', '2000-03-12T00:00:00.000Z',
'2000-03-13T00:00:00.000Z', '2000-03-14T00:00:00.000Z',
'2000-03-15T00:00:00.000Z', '2000-03-16T00:00:00.000Z',
'2000-03-17T00:00:00.000Z', '2000-03-18T00:00:00.000Z',
'2000-03-19T00:00:00.000Z', '2000-03-20T00:00:00.000Z',
'2000-03-21T00:00:00.000Z', '2000-03-22T00:00:00.000Z',
'2000-03-23T00:00:00.000Z', '2000-03-24T00:00:00.000Z',
'2000-03-25T00:00:00.000Z', '2000-03-26T00:00:00.000Z',
'2000-03-27T00:00:00.000Z', '2000-03-28T00:00:00.000Z',
'2000-03-29T00:00:00.000Z', '2000-03-30T00:00:00.000Z',
'2000-03-31T00:00:00.000Z', '2000-04-01T00:00:00.000Z',
'2000-04-02T00:00:00.000Z', '2000-04-03T00:00:00.000Z',
'2000-04-04T00:00:00.000Z', '2000-04-05T00:00:00.000Z',
'2000-04-06T00:00:00.000Z', '2000-04-07T00:00:00.000Z',
'2000-04-08T00:00:00.000Z', '2000-04-09T00:00:00.000Z',
'2000-04-10T00:00:00.000Z', '2000-04-11T00:00:00.000Z',
'2000-04-12T00:00:00.000Z', '2000-04-13T00:00:00.000Z',
'2000-04-14T00:00:00.000Z', '2000-04-15T00:00:00.000Z',
'2000-04-16T00:00:00.000Z', '2000-04-17T00:00:00.000Z',
'2000-04-18T00:00:00.000Z', '2000-04-19T00:00:00.000Z',
'2000-04-20T00:00:00.000Z', '2000-04-21T00:00:00.000Z',
'2000-04-22T00:00:00.000Z', '2000-04-23T00:00:00.000Z',
'2000-04-24T00:00:00.000Z', '2000-04-25T00:00:00.000Z',
'2000-04-26T00:00:00.000Z', '2000-04-27T00:00:00.000Z',
'2000-04-28T00:00:00.000Z', '2000-04-29T00:00:00.000Z',
'2000-04-30T00:00:00.000Z', '2000-05-01T00:00:00.000Z',
'2000-05-02T00:00:00.000Z', '2000-05-03T00:00:00.000Z',
'2000-05-04T00:00:00.000Z', '2000-05-05T00:00:00.000Z',
'2000-05-06T00:00:00.000Z', '2000-05-07T00:00:00.000Z',
'2000-05-08T00:00:00.000Z', '2000-05-09T00:00:00.000Z',
'2000-05-10T00:00:00.000Z', '2000-05-11T00:00:00.000Z',
'2000-05-12T00:00:00.000Z', '2000-05-13T00:00:00.000Z',
'2000-05-14T00:00:00.000Z', '2000-05-15T00:00:00.000Z',
'2000-05-16T00:00:00.000Z', '2000-05-17T00:00:00.000Z',
'2000-05-18T00:00:00.000Z', '2000-05-19T00:00:00.000Z',
'2000-05-20T00:00:00.000Z', '2000-05-21T00:00:00.000Z',
'2000-05-22T00:00:00.000Z', '2000-05-23T00:00:00.000Z',
'2000-05-24T00:00:00.000Z', '2000-05-25T00:00:00.000Z',
'2000-05-26T00:00:00.000Z', '2000-05-27T00:00:00.000Z',
'2000-05-28T00:00:00.000Z', '2000-05-29T00:00:00.000Z',
'2000-05-30T00:00:00.000Z', '2000-05-31T00:00:00.000Z',
'2000-06-01T00:00:00.000Z', '2000-06-02T00:00:00.000Z',
'2000-06-03T00:00:00.000Z', '2000-06-04T00:00:00.000Z',
'2000-06-05T00:00:00.000Z', '2000-06-06T00:00:00.000Z',
'2000-06-07T00:00:00.000Z', '2000-06-08T00:00:00.000Z'])
saved_layer.set_default_permissions()
url = reverse('layer_metadata', args=[saved_layer.service_typename])
resp = self.client.get(url)
self.assertEquals(resp.status_code, 200)
finally:
# Clean up and completely delete the layer
try:
saved_layer.delete()
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
from geonode.geoserver.helpers import cleanup
cleanup(saved_layer.name, saved_layer.uuid)
except BaseException:
pass