def map_detail(request, mapid, snapshot=None, template='maps/map_detail.html'):
'''
The view that show details of each map
'''
try:
user_role = request.GET['user_role']
except:
user_role = None
map_obj = _resolve_map(request, mapid, 'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
# Update count for popularity ranking,
# but do not includes admins or resource owners
if request.user != map_obj.owner and not request.user.is_superuser:
Map.objects.filter(id=map_obj.id).update(
popular_count=F('popular_count') + 1)
if snapshot is None:
config = map_obj.viewer_json(request.user)
else:
config = snapshot_config(snapshot, map_obj, request.user)
config = json.dumps(config)
layers = MapLayer.objects.filter(map=map_obj.id)
approve_form = ResourceApproveForm()
deny_form = ResourceDenyForm()
context_dict = {
'config':
config,
'resource':
map_obj,
'layers':
layers,
'perms_list':
get_perms(request.user, map_obj.get_self_resource()),
'permissions_json':
_perms_info_json(map_obj),
"documents":
get_related_documents(map_obj),
"user_role":
user_role,
"status":
map_obj.status,
"approve_form":
approve_form,
"deny_form":
deny_form,
"denied_comments":
MapAuditActivity.objects.filter(map_submission_activity__map=map_obj),
}
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, map_obj)
return render_to_response(template, RequestContext(request, context_dict))
def layer_approve(request, layer_pk):
if request.method == 'POST':
form = ResourceApproveForm(request.POST)
if form.is_valid():
try:
layer = Layer.objects.get(id=layer_pk)
except Layer.DoesNotExist:
return HttpResponse("requested layer does not exists")
else:
group = layer.group
if request.user not in group.get_managers():
return HttpResponse("you are not allowed to approve this layer")
layer_submission_activity = LayerSubmissionActivity.objects.get(layer=layer, group=group, iteration=layer.current_iteration)
layer_audit_activity = LayerAuditActivity(layer_submission_activity=layer_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
layer.status = 'ACTIVE'
layer.last_auditor = request.user
layer.save()
layer_submission_activity.is_audited = True
layer_submission_activity.save()
layer_audit_activity.comment_subject = comment_subject
layer_audit_activity.comment_body = comment_body
layer_audit_activity.result = 'APPROVED'
layer_audit_activity.auditor = request.user
layer_audit_activity.save()
messages.info(request, 'approved layer succesfully')
return HttpResponseRedirect(reverse('admin-workspace-layer'))
else:
messages.info(request, 'Please write an approve comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-layer'))
else:
return HttpResponseRedirect(reverse('admin-workspace-layer'))
def map_approve(request, map_pk):
if request.method == 'POST':
form = ResourceApproveForm(request.POST)
if form.is_valid():
try:
map = Map.objects.get(id=map_pk)
except Map.DoesNotExist:
return HttpResponse("requested map does not exists")
else:
group = map.group
if request.user not in group.get_managers():
return HttpResponse("you are not allowed to approve this map")
map_submission_activity = MapSubmissionActivity.objects.get(map=map, group=group, iteration=map.current_iteration)
map_audit_activity = MapAuditActivity(map_submission_activity=map_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
map.status = 'ACTIVE'
map.last_auditor = request.user
map.save()
map_submission_activity.is_audited = True
map_submission_activity.save()
map_audit_activity.comment_subject = comment_subject
map_audit_activity.comment_body = comment_body
map_audit_activity.result = 'APPROVED'
map_audit_activity.auditor = request.user
map_audit_activity.save()
messages.info(request, 'approved map succesfully')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
messages.info(request, 'Please write an approve comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
return HttpResponseRedirect(reverse('admin-workspace-map'))
def document_approve(request, document_pk):
if request.method == 'POST':
form = ResourceApproveForm(request.POST)
if form.is_valid():
try:
document = Document.objects.get(id=document_pk)
except Document.DoesNotExist:
return HttpResponse("requested document does not exists")
else:
group = document.group
if request.user not in group.get_managers():
return HttpResponse("you are not allowed to approve this document")
document_submission_activity = DocumentSubmissionActivity.objects.get(document=document, group=group, iteration=document.current_iteration)
document_audit_activity = DocumentAuditActivity(document_submission_activity=document_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
document.status = 'ACTIVE'
document.last_auditor = request.user
document.save()
document_submission_activity.is_audited = True
document_submission_activity.save()
document_audit_activity.comment_subject = comment_subject
document_audit_activity.comment_body = comment_body
document_audit_activity.result = 'APPROVED'
document_audit_activity.auditor = request.user
document_audit_activity.save()
messages.info(request, 'approved document succesfully')
return HttpResponseRedirect(reverse('admin-workspace-document'))
else:
messages.info(request, 'Please write an approve comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-document'))
else:
return HttpResponseRedirect(reverse('admin-workspace-document'))
def map_approve(request, map_pk):
if request.method == 'POST':
form = ResourceApproveForm(request.POST)
if form.is_valid():
try:
map = Map.objects.get(id=map_pk)
except Map.DoesNotExist:
return Http404("requested map does not exists")
else:
group = map.group
if request.user not in group.get_managers():
if request.user != map.owner:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to approve this map.")})), status=401)
# return HttpResponse("you are not allowed to approve this map")
map_submission_activity = MapSubmissionActivity.objects.get(map=map, group=group, iteration=map.current_iteration)
map_audit_activity = MapAuditActivity(map_submission_activity=map_submission_activity)
comment_body = request.POST.get('comment')
comment_subject = request.POST.get('comment_subject')
map.status = 'ACTIVE'
map.last_auditor = request.user
map.save()
permissions = _perms_info_json(map)
perm_dict = json.loads(permissions)
if request.POST.get('view_permission'):
if not 'AnonymousUser' in perm_dict['users']:
perm_dict['users']['AnonymousUser'] = []
perm_dict['users']['AnonymousUser'].append('view_resourcebase')
else:
if not 'view_resourcebase' in perm_dict['users']['AnonymousUser']:
perm_dict['users']['AnonymousUser'].append('view_resourcebase')
if request.POST.get('download_permission'):
if not 'AnonymousUser' in perm_dict['users']:
perm_dict['users']['AnonymousUser'] = []
perm_dict['users']['AnonymousUser'].append('download_resourcebase')
else:
if not 'download_resourcebase' in perm_dict['users']['AnonymousUser']:
perm_dict['users']['AnonymousUser'].append('download_resourcebase')
map.set_permissions(perm_dict)
# notify map owner that someone have approved the map
if request.user != map.owner:
recipient = map.owner
notify.send(request.user, recipient=recipient, actor=request.user,
target=map, verb='approved your map')
map_submission_activity.is_audited = True
map_submission_activity.save()
map_audit_activity.comment_subject = comment_subject
map_audit_activity.comment_body = comment_body
map_audit_activity.result = 'APPROVED'
map_audit_activity.auditor = request.user
map_audit_activity.save()
messages.info(request, 'Approved map succesfully')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
messages.info(request, 'Please write an approve comment and try again')
return HttpResponseRedirect(reverse('admin-workspace-map'))
else:
return HttpResponseRedirect(reverse('admin-workspace-map'))
def layer_detail(request, layername, template='layers/layer_detail.html'):
try:
user_role = request.GET['user_role']
except:
user_role=None
layer = _resolve_layer(
request,
layername,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
user = request.user
edit_permit = False
if layer.owner == user and layer.status in ['DRAFT', 'ACTIVE', 'DENIED']:
edit_permit = True
elif user in layer.group.get_managers() and layer.status in ['PENDING', 'ACTIVE', 'DENIED']:
edit_permit = True
if not edit_permit and layer.status=='ACTIVE':
edit_permit = True
# if the edit request is not valid then just return from here
if not edit_permit:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You dont have permission to edit this layer.")})), status=401)
# return HttpResponse('You dont have permission to edit this layer')
# assert False, str(layer_bbox)
config = layer.attribute_config()
# Add required parameters for GXP lazy-loading
layer_bbox = layer.bbox
bbox = [float(coord) for coord in list(layer_bbox[0:4])]
config["srs"] = getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913')
config["bbox"] = bbox if config["srs"] != 'EPSG:900913' \
else llbbox_to_mercator([float(coord) for coord in bbox])
config["title"] = layer.title
config["queryable"] = True
if layer.storeType == "remoteStore":
service = layer.service
source_params = {
"ptype": service.ptype,
"remote": True,
"url": service.base_url,
"name": service.name}
maplayer = GXPLayer(
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config),
source_params=json.dumps(source_params))
else:
maplayer = GXPLayer(
name=layer.typename,
ows_url=layer.ows_url,
layer_params=json.dumps(config))
# Update count for popularity ranking,
# but do not includes admins or resource owners
if request.user != layer.owner and not request.user.is_superuser:
Layer.objects.filter(
id=layer.id).update(popular_count=F('popular_count') + 1)
# center/zoom don't matter; the viewer will center on the layer bounds
map_obj = GXPMap(projection=getattr(settings, 'DEFAULT_MAP_CRS', 'EPSG:900913'))
NON_WMS_BASE_LAYERS = [
la for la in default_map_config()[1] if la.ows_url is None]
metadata = layer.link_set.metadata().filter(
name__in=settings.DOWNLOAD_FORMATS_METADATA)
granules = None
all_granules = None
filter = None
if layer.is_mosaic:
try:
cat = gs_catalog
cat._cache.clear()
store = cat.get_store(layer.name)
coverages = cat.mosaic_coverages(store)
filter = None
try:
if request.GET["filter"]:
filter = request.GET["filter"]
except:
pass
offset = 10 * (request.page - 1)
granules = cat.mosaic_granules(coverages['coverages']['coverage'][0]['name'], store, limit=10,
offset=offset, filter=filter)
all_granules = cat.mosaic_granules(coverages['coverages']['coverage'][0]['name'], store, filter=filter)
except:
granules = {"features": []}
all_granules = {"features": []}
approve_form = ResourceApproveForm()
deny_form = ResourceDenyForm()
metadata_field_list = ['owner', 'title', 'date', 'date_type', 'edition', 'abstract', 'purpose',
'maintenance_frequency', 'regions', 'restriction_code_type', 'constraints_other', 'license',
'language', 'spatial_representation_type', 'resource_type', 'temporal_extent_start',
'temporal_extent_end', 'supplemental_information', 'data_quality_statement', 'thumbnail_url',
'elevation_regex', 'time_regex', 'keywords',
'category']
if request.user == layer.owner or request.user in layer.group.get_managers():
if not layer.attributes:
messages.info(request, 'Please update layer metadata, missing some informations')
elif not layer.metadata_author:
messages.info(request, 'Please update layer metadata, missing some informations')
else:
for field in metadata_field_list:
if not getattr(layer, layer._meta.get_field(field).name):
messages.info(request, 'Please update layer metadata, missing some informations')
break
# layer_name = layer.service_typename
# geoserver_user = OGC_SERVER['default']['USER']
# geoserver_password = OGC_SERVER['default']['PASSWORD']
# style_url = OGC_SERVER['default']['PUBLIC_LOCATION'] + "rest/layers/" + layer_name + ".json"
# response1 = requests.get(style_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password))
# sld_file_name_url = response1.json()['layer']['defaultStyle']['href']
# response2 = requests.get(sld_file_name_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password))
# file_name = response2.json()['style']['filename']
# sld_file_url = OGC_SERVER['default']['PUBLIC_LOCATION'] + "rest/styles/" + file_name
# sld_content = requests.get(sld_file_url, auth=HTTPBasicAuth(geoserver_user, geoserver_password)).content
#
# xlink = ''
# try:
# dict1 = xmltodict.parse(sld_content)
# dict2 = dict1['sld:StyledLayerDescriptor']['sld:NamedLayer']['sld:UserStyle']['sld:FeatureTypeStyle']\
# ['sld:Rule']['sld:PointSymbolizer']
# xlink = dict2['sld:Graphic']['sld:ExternalGraphic']['sld:OnlineResource']['@xlink:href']
# except:
# pass
xlink = style_chart_legend_color(layer)
context_dict = {
"resource": layer,
'perms_list': get_perms(request.user, layer.get_self_resource()),
"permissions_json": _perms_info_json(layer),
"documents": get_related_documents(layer),
"metadata": metadata,
"is_layer": True,
"wps_enabled": settings.OGC_SERVER['default']['WPS_ENABLED'],
"granules": granules,
"all_granules": all_granules,
"filter": filter,
"user_role": user_role,
"approve_form": approve_form,
"deny_form": deny_form,
"denied_comments": LayerAuditActivity.objects.filter(layer_submission_activity__layer=layer),
"status": layer.status,
"chart_link" : xlink
}
context_dict["viewer"] = json.dumps(
map_obj.viewer_json(request.user, * (NON_WMS_BASE_LAYERS + [maplayer])))
context_dict["preview"] = getattr(
settings,
'LAYER_PREVIEW_LIBRARY',
'leaflet')
if request.user.has_perm('download_resourcebase', layer.get_self_resource()):
if layer.storeType == 'dataStore':
links = layer.link_set.download().filter(
name__in=settings.DOWNLOAD_FORMATS_VECTOR)
else:
links = layer.link_set.download().filter(
name__in=settings.DOWNLOAD_FORMATS_RASTER)
context_dict["links"] = links
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, layer)
return render_to_response(template, RequestContext(request, context_dict))
def document_detail(request, docid):
"""
The view that show details of each document
"""
try:
user_role = request.GET['user_role']
except:
user_role=None
document = None
try:
document = _resolve_document(
request,
docid,
'base.view_resourcebase',
_PERMISSION_MSG_VIEW)
except Http404:
return HttpResponse(
loader.render_to_string(
'404.html', RequestContext(
request, {
})), status=404)
except PermissionDenied:
return HttpResponse(
loader.render_to_string(
'401.html', RequestContext(
request, {
'error_message': _("You are not allowed to view this document.")})), status=403)
if document is None:
return HttpResponse(
'An unknown error has occured.',
content_type="text/plain",
status=401
)
else:
try:
related = document.content_type.get_object_for_this_type(
id=document.object_id)
except:
related = ''
# Update count for popularity ranking,
# but do not includes admins or resource owners
if request.user != document.owner and not request.user.is_superuser:
Document.objects.filter(id=document.id).update(popular_count=F('popular_count') + 1)
metadata = document.link_set.metadata().filter(
name__in=settings.DOWNLOAD_FORMATS_METADATA)
approve_form = ResourceApproveForm()
deny_form = ResourceDenyForm()
context_dict = {
'perms_list': get_perms(request.user, document.get_self_resource()),
'permissions_json': _perms_info_json(document),
'resource': document,
'metadata': metadata,
'imgtypes': IMGTYPES,
'related': related,
"user_role": user_role,
"status": document.status,
"approve_form": approve_form,
"deny_form": deny_form,
"denied_comments": DocumentAuditActivity.objects.filter(document_submission_activity__document=document),
}
if settings.SOCIAL_ORIGINS:
context_dict["social_links"] = build_social_links(request, document)
if getattr(settings, 'EXIF_ENABLED', False):
try:
from geonode.contrib.exif.utils import exif_extract_dict
exif = exif_extract_dict(document)
if exif:
context_dict['exif_data'] = exif
except:
print "Exif extraction failed."
return render_to_response(
"documents/document_detail.html",
RequestContext(request, context_dict))